SlideShare a Scribd company logo

Virtual Machine for Regular Expressions

A
Alexander Yakushev

The document discusses the implementation of a virtual machine for regular expressions, highlighting the need for token-level rules rather than character-level rules found in existing libraries. It presents various methods of regex engine implementation, including backtracking, full FSM unrolling, and dynamic FSM unrolling, emphasizing their complexity and runtime efficiency. The TrexVM is introduced as a solution that utilizes multi-threading to execute regex operations in a more efficient manner by processing tokens step by step.

Software
1 of 102
Downloaded 10 times
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
Virtual Machine for Regular Expressions Alexander Yakushev @unlog1c JEEConf 2018
Theory
Stephen Cole Kleene - Inventor of regular expressions ^ This guy
What's a regular expression? A text-matching automaton. /^a+b?(cd*|e)$/ "aaaaabcddd" ✓ "aabbdd" ❌
Regular expression as FSM ^a+b?(cd*|e)$
Regular expression as FSM ^a+b?(cd*|e)$
Why implement regular expressions yourself? All modern programming languages provide regular expressions with core library.
Why implement regular expressions yourself? All modern programming languages provide regular expressions with core library. But those are only character-level regexps.
At Grammarly, we need to define token-level rules that are describable with regex semantics. Why implement regular expressions yourself? <person> = (<honorific>? <first-name-dict>+ <last-name-dict>) | (<determiner>? <profession-dict>)
Ways of implementing regex engines 1. Backtracking ○ Runtime: exponential
Backtracking implementation (by Rob Pike) int match(char *regexp, char *text) { if (regexp[0] == '0') return 1; if (regexp[1] == '*') return matchstar(regexp[0], regexp+2, text); if (*text!='0' && (regexp[0]=='.' || regexp[0]==*text)) return match(regexp+1, text+1); return 0; } int matchstar(char c, char *regexp, char *text) { do { if (match(regexp, text)) return 1; } while (*text != '0' && (*text++ == c || c == '.')); return 0; }
Backtracking implementation ● Good: simple and short. ○ Fit into 15 lines! ● Bad: exponential complexity.
How to kill a snake $ python >>> import re >>> s = "a" * 50 >>> re.match("(a|aa)*b", s) # crickets… chirp chirp
Ways of implementing regex engines 1. Backtracking ○ Runtime: exponential 2. Full FSM unroll (static NFA->DFA) ○ Compilation: exponential time and memory ○ Runtime: linear O(n)
Ways of implementing regex engines 1. Backtracking ○ Runtime: exponential 2. Full FSM unroll (static NFA->DFA) ○ Compilation: exponential time and memory ○ Runtime: linear O(n) 3. Dynamic FSM unroll (“lazy” DFA construction) ○ Runtime: linear O(nm)
Dynamic FSM unroll 1. Google RE2* 2. Rust’s regex library† 3. Virtual machine approach‡ * github.com/google/re2 † github.com/rust-lang/regex ‡ swtch.com/~rsc/regexp/regexp2.html
Virtual machines
MOV CX, 10 MOV AX, [BP] L: CMP CX, 0 JZ E SHL AX, 1 DEC CX JMP L E: RET Machine code (actually, assembly) AX 123 BX 234 CX 9 ... IP 0 Registers Crude example of an x86 machine
MOV CX, 10 MOV AX, [BP] L: CMP CX, 0 JZ E SHL AX, 1 DEC CX JMP L E: RET Machine code (actually, assembly) AX 123 BX 234 CX 9 ... IP 0 Thread 1 Registers AX 321 BX 432 CX 0 ... IP 7 Thread 2 Registers AX 879 BX 567 CX 4 ... IP 3 Thread 3 Registers Crude example of an x86 machine
MOV CX, 10 MOV AX, [BP] L: CMP CX, 0 JZ E SHL AX, 1 DEC CX JMP L E: RET Machine code (actually, assembly) AX 123 BX 234 CX 9 ... IP 0 Thread 1 Registers Thread 2 Registers AX 321 BX 432 CX 0 ... IP 7 Crude example of a virtual machine
Examples of virtual machines 1. VirtualBox/VMWare/KVM 2. Java Virtual Machine 3. Domain-specific VMs
TrexVM (Token RegEX Virtual Machine) ● Consumes input sequence token by token. ○ Never goes back to previous tokens. ● IP (instruction pointer) tracks the currently executed instruction. ● Instructions: ○ CMP x Compare current token to x, increment IP if equal, fail if not. ○ JUMP label Unconditionally set IP to the point designated by label. ○ FORK label Increment IP and spawn additional thread that jumps to label.
TrexVM (Token RegEX Virtual Machine) ● All threads are executed in a lock-step. ○ Execute all CMP instructions simultaneously. ○ If some threads point not to CMP, statically unroll them. ● Execution continues until one thread reaches the end of the program (successful match) or all threads are dead (failed match)
TrexVM sample run aaab Input string ↑ 1→ L1: CMP a FORK L1 CMP b Program
TrexVM sample run aaab Input string ↑1→ L1: CMP a FORK L1 CMP b Program
TrexVM sample run aaab Input string ↑ 1→ 2→ L1: CMP a FORK L1 CMP b Program
TrexVM sample run aaab Input string ↑2→ L1: CMP a FORK L1 CMP b Program
TrexVM sample run aaab Input string ↑ 2→ 3→ L1: CMP a FORK L1 CMP b Program
TrexVM sample run aaab Input string ↑3→ L1: CMP a FORK L1 CMP b Program
TrexVM sample run L1: CMP a FORK L1 CMP b Program aaab Input string ↑ 3→ 4→
TrexVM sample run aaab Input string ↑ 3→ Success! L1: CMP a FORK L1 CMP b Program
TrexVM sample run aaab Input string ↑ 3→ Success! Regex: a+b L1: CMP a FORK L1 CMP b Program
TrexVM FORK L1 CMP a L1: FORK L2 CMP b JUMP L1 L2: CMP c Guess the regular expression:
TrexVM FORK L1 CMP a L1: FORK L2 CMP b JUMP L1 L2: CMP c Regex: a?b*c Guess the regular expression:
TrexVM: next iteration Added support for match groups. Each thread now has a register bank (beyond just IP register). New instructions: ● SAVEL group — save current position in input as beginning of group. ● SAVER group — save current position in input as ending of group. ● FORKSTAY label — FORK which gives the staying thread a higher priority. ● FORKJUMP label — FORK which gives the jumping thread a higher priority. Matching stops when the thread with the highest priority succeeds.
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst snd T1 1→
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ 2→ Reg L R fst 0 snd T2
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ 2→ Reg L R fst 0 1 snd T2
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ 2→ Reg L R fst 0 1 snd 1 T2
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ 2→ Reg L R fst 0 snd T2
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ Reg L R fst 0 2 snd T2 2→
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ Reg L R fst 0 2 snd 2 T2 2→
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 Reg L R fst 0 2 snd 2 T2 2→ 1→
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 Reg L R fst 0 snd T2 1→ 2→ 3→ Reg L R fst 0 2 snd 2 3 T3
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 Reg L R fst 0 3 snd T2 1→ 3→ Reg L R fst 0 2 snd 2 3 T3 2→
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 Reg L R fst 0 3 snd 3 T2 1→ 3→ Reg L R fst 0 2 snd 2 3 T3 2→
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers 3→ Reg L R fst 0 2 snd 2 3 T3 Success! Match groups: fst: aa snd: b
SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers 3→ Reg L R fst 0 2 snd 2 3 T3 Success! Match groups: fst: aa snd: b Regex: ([ab]+)(b)
Another run
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string ↑ TrexVM1.1 second run Thread registers Reg L R fst snd T1 1→
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string ↑ TrexVM1.1 second run Thread registers Reg L R fst 0 snd T1 1→
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string ↑ TrexVM1.1 second run Thread registers Reg L R fst 0 snd T1 1→
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 snd T1 1→ 2→ ↑ Reg L R fst 0 snd T2
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd T1 1→ 2→ ↑ Reg L R fst 0 snd T2
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 T1 1→ 2→ ↑ Reg L R fst 0 snd T2
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 T1 1→ 2→ ↑ Reg L R fst 0 1 snd 1 T2 3→ Reg L R fst 0 snd T3
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 T1 1→ 2→ ↑ Reg L R fst 0 1 snd 1 1 T2
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 T1 1→ 2→ ↑ Reg L R fst 0 1 snd 1 1 T2
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 2 T1 1→ ↑
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 2 T1 1→ ↑ Success! Match groups: fst: a snd: b
SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 2 T1 1→ ↑ Success! Match groups: fst: a snd: b Regex: ([ab]+?)(b?)
Implementation
Concatenation #INCLUDE regex1 #INCLUDE regex2 ... #INCLUDE regexN (cat regex1 regex2 … regexN)
Quantifiers #LABEL _LOOP #INCLUDE regex FORKJUMP _LOOP (+ regex) #LABEL _LOOP #INCLUDE regex FORKSTAY _LOOP (+? regex)
Quantifiers #LABEL _START FORKSTAY _END #INCLUDE regex JUMP _START #LABEL _END (* regex) #LABEL _START FORKJUMP _END #INCLUDE regex JUMP _START #LABEL _END (*? regex)
Quantifiers FORKSTAY _SKIP #INCLUDE regex #LABEL _SKIP (? regex) FORKJUMP _SKIP #INCLUDE regex #LABEL _SKIP (?? regex)
Alternation FORKSTAY _ALT #INCLUDE regex1 JUMP _END #LABEL _ALT #INCLUDE regex2 #LABEL _END (| regex1 regex2)
Match groups SAVEL name #INCLUDE regex SAVER name (as group regex)
Possible CMP arguments ● String (check if token is equal) ● Char-level regex (check if token matches) ● Hashset/map (check if it contains the token) ● Arbitrary predicate (check if token satisfies)
TrexVM syntax (as :person (| (cat (? is-honorific) (+ first-name-dict) last-name-dict)) (cat (? is-determiner) profession-dict)) Now we can write regular expressions like this:
Extra features (cat (+ name-dict) (?! is-stop-word)) Negative and positive (nested) look aheads
Extra features (cat (+ name-dict) (?! is-stop-word)) Negative and positive (nested) look aheads Implemented as a subvirtual machine inside each thread.
Start/end of sequence anchors (^ and $) (cat < is-number (? is-word) >) Extra features
Extra features (cat (*? .) regex…) Cheap anchor-free macthing
Loop detection (rx-find (cat (* (| a (cat a a))) b) (repeat 300 a)) => nil Extra features
Composability (def numbered-street-name (+ (| is-ordinal-number street-name-dict)) (def street (| (cat (? #"d+") numbered-street-name street-marker-dict) (cat #"d+" numbered-street-name #{"Count" "Drive"})) Extra features
Shortcomings ● No look-behinds ● No backreferences ● Can’t find all matches (only first match) ● Overkill complexity for trivial cases
Under the hood
Naive implementation ● 300 lines of Clojure ● Immutable VM and Thread objects ● Very concise and debuggable code
Naive implementation ● 300 lines of Clojure ● Immutable VM and Thread objects ● Very concise and debuggable code ● Slow! ○ Real-world regex scan takes ~1ms per sentence
Optimizations Inline caching of compiled regexes.
Bad Java regexp usage for (String sentence : sentences) { sentence.matches("^(?i[rea]lly* hard+ regex))$"); }
Good Java regexp usage Pattern p = Pattern.compile("^(?i[rea]lly* hard+ regex))$"); for (String sentence : sentences) { p.matcher(sentence).matches(); }
Clojure: the power of macros (for [sentence-tokens all-sentences] (find (trex (+ (? company-name)) ...) sentence-tokens))
Optimizations Inline caching of compiled regexes. 3x performance improvement.
Optimizations ● Started rewriting parts of the implementation into Java.
Optimizations ● Started rewriting parts of the implementation into Java. ● Made some objects mutable.
Optimizations ● Started rewriting parts of the implementation into Java. ● Made some objects mutable. ● Made everything mutable.
Optimizations ● Started rewriting parts of the implementation into Java. ● Made some objects mutable. ● Made everything mutable. ● Made some things immutable again.
● 300 lines of Java ○ VM completely rewritten in Java. ● 300 lines of Clojure ○ Function definitions, compiler, API (find, matches, …) Final version
● 300 lines of Java ○ VM completely rewritten in Java. ● 300 lines of Clojure ○ Function definitions, compiler, API (find, matches, …) ● Mix of mutable and immutable objects with copy-on-write fields. Final version
● 300 lines of Java ○ VM completely rewritten in Java. ● 300 lines of Clojure ○ Function definitions, compiler, API (find, matches, …) ● Mix of mutable and immutable objects with copy-on-write fields. ● Performance x20 of the initial version. ○ Previous regex takes 50μs per sentence. Final version
Future work ● Improve the performance for trivial cases. ○ More static analysis and optimization in regex compilation phase.
Future work ● Improve the performance for trivial cases. ○ More static analysis and optimization in regex compilation phase. ● JIT compiler and branch prediction ○ Leverage runtime knowledge about often-failed CMPs in the regex.
Future work ● Improve the performance for trivial cases. ○ More static analysis and optimization in regex compilation phase. ● JIT compiler and branch prediction ○ Leverage runtime knowledge about often-failed CMPs in the regex. ○ Make it vulnerable to Meltdown/Spectre.
Future work ● Improve the performance for trivial cases. ○ More static analysis and optimization in regex compilation phase. ● JIT compiler and branch prediction ○ Leverage runtime knowledge about often-failed CMPs in the regex. ○ Make it vulnerable to Meltdown/Spectre. ● Investigate if look-behinds are possible (through hacks and reduced perf)
Conclusions ● Old papers contain great ideas ● Knowledge from university can be useful ● Make it work, then make it fast
References ● Original paper: https://swtch.com/~rsc/regexp/regexp2.html ● Open-source implementation (in Clojure): https://github.com/cgrand/seqexp ● Synacor Challenge https://challenge.synacor.com
.+the end$

More Related Content

PDF
How it's made: C++ compilers (GCC)
Sławomir Zborowski
 
PDF
Integrating R with C++: Rcpp, RInside and RProtoBuf
Romain Francois
 
PDF
Java/Scala Lab: Руслан Шевченко - Implementation of CSP (Communication Sequen...
GeeksLab Odessa
 
PDF
Rcpp
Ajay Ohri
 
PPTX
Streams for the Web
Domenic Denicola
 
PDF
Making our Future better
legendofklang
 
PDF
Csp scala wixmeetup2016
Ruslan Shevchenko
 
PDF
GCC LTO
Wang Hsiangkai
 
How it's made: C++ compilers (GCC)
Sławomir Zborowski
 
Integrating R with C++: Rcpp, RInside and RProtoBuf
Romain Francois
 
Java/Scala Lab: Руслан Шевченко - Implementation of CSP (Communication Sequen...
GeeksLab Odessa
 
Rcpp
Ajay Ohri
 
Streams for the Web
Domenic Denicola
 
Making our Future better
legendofklang
 
Csp scala wixmeetup2016
Ruslan Shevchenko
 
GCC LTO
Wang Hsiangkai
 

What's hot (20)

PDF
Good news, everybody! Guile 2.2 performance notes (FOSDEM 2016)
Igalia
 
PPT
Introduction to gdb
Owen Hsu
 
PDF
Performance evaluation with Arm HPC tools for SVE
Linaro
 
ODP
C Under Linux
mohan43u
 
PDF
Porting and Optimization of Numerical Libraries for ARM SVE
Linaro
 
PPTX
Berkeley Packet Filters
Kernel TLV
 
ODP
ocelot
sean chen
 
PDF
Arm tools and roadmap for SVE compiler support
Linaro
 
PPTX
Staring into the eBPF Abyss
Sasha Goldshtein
 
PDF
Javascript Secrets - Front in Floripa 2015
Fernando Daciuk
 
PDF
Pragmatic Optimization in Modern Programming - Mastering Compiler Optimizations
Marina Kolpakova
 
PPTX
Gnu debugger
Gizem Çetin
 
PDF
Low pause GC in HotSpot
jClarity
 
PDF
Code GPU with CUDA - Optimizing memory and control flow
Marina Kolpakova
 
PDF
LTO plugin
Wang Hsiangkai
 
PDF
Debugging node in prod
Yunong Xiao
 
PDF
不深不淺，帶你認識 LLVM (Found LLVM in your life)
Douglas Chen
 
PDF
Knowing your Garbage Collector / Python Madrid
fcofdezc
 
PDF
Introduction to RevKit
Mathias Soeken
 
DOCX
Exercice.docx
imane26
 
Good news, everybody! Guile 2.2 performance notes (FOSDEM 2016)
Igalia
 
Introduction to gdb
Owen Hsu
 
Performance evaluation with Arm HPC tools for SVE
Linaro
 
C Under Linux
mohan43u
 
Porting and Optimization of Numerical Libraries for ARM SVE
Linaro
 
Berkeley Packet Filters
Kernel TLV
 
ocelot
sean chen
 
Arm tools and roadmap for SVE compiler support
Linaro
 
Staring into the eBPF Abyss
Sasha Goldshtein
 
Javascript Secrets - Front in Floripa 2015
Fernando Daciuk
 
Pragmatic Optimization in Modern Programming - Mastering Compiler Optimizations
Marina Kolpakova
 
Gnu debugger
Gizem Çetin
 
Low pause GC in HotSpot
jClarity
 
Code GPU with CUDA - Optimizing memory and control flow
Marina Kolpakova
 
LTO plugin
Wang Hsiangkai
 
Debugging node in prod
Yunong Xiao
 
不深不淺，帶你認識 LLVM (Found LLVM in your life)
Douglas Chen
 
Knowing your Garbage Collector / Python Madrid
fcofdezc
 
Introduction to RevKit
Mathias Soeken
 
Exercice.docx
imane26
 
Ad

Similar to Virtual Machine for Regular Expressions (20)

PPTX
Advanced procedures in assembly language Full chapter ppt
Muhammad Sikandar Mustafa
 
PDF
Lecture 3 RE NFA DFA
Rebaz Najeeb
 
PPTX
Computer Architecture Assignment Help
Architecture Assignment Help
 
PDF
lec15_x86procedure_4up.pdf
hasan58964
 
PPTX
07 140430-ipp-languages used in llvm during compilation
Adam Husár
 
PDF
Implement an MPI program to perform matrix-matrix multiplication AB .pdf
meerobertsonheyde608
 
PDF
Exploitation Crash Course
UTD Computer Security Group
 
PDF
R/C++ talk at earl 2014
Romain Francois
 
PDF
CAMP-V: Ultimate RISC-V Bootcamp sponsored by MERL and RISC-V
shazaib9
 
PDF
System Hacking Tutorial #2 - Buffer Overflow - Overwrite EIP
sanghwan ahn
 
PDF
Continuation Passing Style and Macros in Clojure - Jan 2012
Leonardo Borges
 
PDF
Make ARM Shellcode Great Again - HITB2018PEK
Saumil Shah
 
PPTX
Node.js - Advanced Basics
Doug Jones
 
PDF
Assembly class
Jonah Marrs
 
PPT
other-architectures.ppt
Jaya Chavan
 
PDF
Pragmatic Optimization in Modern Programming - Demystifying the Compiler
Marina Kolpakova
 
PPT
Assembly language programming_fundamentals 8086
Shehrevar Davierwala
 
PDF
[FT-11][suhorng] “Poor Man's” Undergraduate Compilers
Functional Thursday
 
PPT
chapt_5+6AssemblyLanguagecompleteclear.ppt
mubashrabashir540
 
PDF
Visual Studio를 이용한 어셈블리어 학습 part 2
YEONG-CHEON YOU
 
Advanced procedures in assembly language Full chapter ppt
Muhammad Sikandar Mustafa
 
Lecture 3 RE NFA DFA
Rebaz Najeeb
 
Computer Architecture Assignment Help
Architecture Assignment Help
 
lec15_x86procedure_4up.pdf
hasan58964
 
07 140430-ipp-languages used in llvm during compilation
Adam Husár
 
Implement an MPI program to perform matrix-matrix multiplication AB .pdf
meerobertsonheyde608
 
Exploitation Crash Course
UTD Computer Security Group
 
R/C++ talk at earl 2014
Romain Francois
 
CAMP-V: Ultimate RISC-V Bootcamp sponsored by MERL and RISC-V
shazaib9
 
System Hacking Tutorial #2 - Buffer Overflow - Overwrite EIP
sanghwan ahn
 
Continuation Passing Style and Macros in Clojure - Jan 2012
Leonardo Borges
 
Make ARM Shellcode Great Again - HITB2018PEK
Saumil Shah
 
Node.js - Advanced Basics
Doug Jones
 
Assembly class
Jonah Marrs
 
other-architectures.ppt
Jaya Chavan
 
Pragmatic Optimization in Modern Programming - Demystifying the Compiler
Marina Kolpakova
 
Assembly language programming_fundamentals 8086
Shehrevar Davierwala
 
[FT-11][suhorng] “Poor Man's” Undergraduate Compilers
Functional Thursday
 
chapt_5+6AssemblyLanguagecompleteclear.ppt
mubashrabashir540
 
Visual Studio를 이용한 어셈블리어 학습 part 2
YEONG-CHEON YOU
 
Ad

Recently uploaded (20)

PDF
SAP S4 Hana Brochure 3 (PTS SYSTEMS AND SOLUTIONS)
pts464036
 
PPTX
Transform Your Business with a Software ERP System
Canada Software Company
 
PPTX
CHAPTER 2 - PM Management and IT Context
KevinPutra14
 
PDF
How to Migrate SBCGlobal Email to Yahoo Easily
raymondjones7273
 
PDF
Navsoft: AI-Powered Business Solutions & Custom Software Development
Navsoft
 
PDF
Which alternative to Crystal Reports is best for small or large businesses.pdf
Varsha Nayak
 
PPTX
Reimagine Home Health with the Power of Agentic AI​
AutomationEdge Technologies
 
PDF
Audit Checklist Design Aligning with ISO, IATF, and Industry Standards — Omne...
rohnjim07
 
PDF
Raksha Bandhan Grocery Pricing Trends in India 2025.pdf
Actowiz Solustions
 
PPTX
Agentic AI Use Case- Contract Lifecycle Management (CLM).pptx
mhxyzzp
 
PDF
top salesforce developer skills in 2025.pdf
CloudMetic
 
PPTX
Lecture 3: Operating Systems Introduction to Computer Hardware Systems
hci7se
 
PDF
medical staffing services at VALiNTRY
Tiyan Grayson
 
PPTX
ai tools demonstartion for schools and inter college
harshavardhanreddyka11
 
PPTX
Oracle E-Business Suite: A Comprehensive Guide for Modern Enterprises
Conacent Consulting
 
PDF
Wondershare Filmora 15 Crack With Activation Key [2025
ghrom2211g
 
PDF
2025 Textile ERP Trends: SAP, Odoo & Oracle
Aetos Technologies
 
PDF
Nekopoi APK 2025 free lastest update
umarali35kp
 
PDF
Odoo Companies in India – Driving Business Transformation.pdf
azhuhardeen1968
 
PDF
Claude Code: Everyone is a 10x Developer - A Comprehensive AI-Powered CLI Tool
William Chong
 
SAP S4 Hana Brochure 3 (PTS SYSTEMS AND SOLUTIONS)
pts464036
 
Transform Your Business with a Software ERP System
Canada Software Company
 
CHAPTER 2 - PM Management and IT Context
KevinPutra14
 
How to Migrate SBCGlobal Email to Yahoo Easily
raymondjones7273
 
Navsoft: AI-Powered Business Solutions & Custom Software Development
Navsoft
 
Which alternative to Crystal Reports is best for small or large businesses.pdf
Varsha Nayak
 
Reimagine Home Health with the Power of Agentic AI​
AutomationEdge Technologies
 
Audit Checklist Design Aligning with ISO, IATF, and Industry Standards — Omne...
rohnjim07
 
Raksha Bandhan Grocery Pricing Trends in India 2025.pdf
Actowiz Solustions
 
Agentic AI Use Case- Contract Lifecycle Management (CLM).pptx
mhxyzzp
 
top salesforce developer skills in 2025.pdf
CloudMetic
 
Lecture 3: Operating Systems Introduction to Computer Hardware Systems
hci7se
 
medical staffing services at VALiNTRY
Tiyan Grayson
 
ai tools demonstartion for schools and inter college
harshavardhanreddyka11
 
Oracle E-Business Suite: A Comprehensive Guide for Modern Enterprises
Conacent Consulting
 
Wondershare Filmora 15 Crack With Activation Key [2025
ghrom2211g
 
2025 Textile ERP Trends: SAP, Odoo & Oracle
Aetos Technologies
 
Nekopoi APK 2025 free lastest update
umarali35kp
 
Odoo Companies in India – Driving Business Transformation.pdf
azhuhardeen1968
 
Claude Code: Everyone is a 10x Developer - A Comprehensive AI-Powered CLI Tool
William Chong
 

Virtual Machine for Regular Expressions

  • 1. Virtual Machine for Regular Expressions Alexander Yakushev @unlog1c JEEConf 2018
  • 3. Stephen Cole Kleene - Inventor of regular expressions ^ This guy
  • 4. What's a regular expression? A text-matching automaton. /^a+b?(cd*|e)$/ "aaaaabcddd" ✓ "aabbdd" ❌
  • 5. Regular expression as FSM ^a+b?(cd*|e)$
  • 6. Regular expression as FSM ^a+b?(cd*|e)$
  • 7. Why implement regular expressions yourself? All modern programming languages provide regular expressions with core library.
  • 8. Why implement regular expressions yourself? All modern programming languages provide regular expressions with core library. But those are only character-level regexps.
  • 9. At Grammarly, we need to define token-level rules that are describable with regex semantics. Why implement regular expressions yourself? <person> = (<honorific>? <first-name-dict>+ <last-name-dict>) | (<determiner>? <profession-dict>)
  • 10. Ways of implementing regex engines 1. Backtracking ○ Runtime: exponential
  • 11. Backtracking implementation (by Rob Pike) int match(char *regexp, char *text) { if (regexp[0] == '0') return 1; if (regexp[1] == '*') return matchstar(regexp[0], regexp+2, text); if (*text!='0' && (regexp[0]=='.' || regexp[0]==*text)) return match(regexp+1, text+1); return 0; } int matchstar(char c, char *regexp, char *text) { do { if (match(regexp, text)) return 1; } while (*text != '0' && (*text++ == c || c == '.')); return 0; }
  • 12. Backtracking implementation ● Good: simple and short. ○ Fit into 15 lines! ● Bad: exponential complexity.
  • 13. How to kill a snake $ python >>> import re >>> s = "a" * 50 >>> re.match("(a|aa)*b", s) # crickets… chirp chirp
  • 14. Ways of implementing regex engines 1. Backtracking ○ Runtime: exponential 2. Full FSM unroll (static NFA->DFA) ○ Compilation: exponential time and memory ○ Runtime: linear O(n)
  • 15. Ways of implementing regex engines 1. Backtracking ○ Runtime: exponential 2. Full FSM unroll (static NFA->DFA) ○ Compilation: exponential time and memory ○ Runtime: linear O(n) 3. Dynamic FSM unroll (“lazy” DFA construction) ○ Runtime: linear O(nm)
  • 16. Dynamic FSM unroll 1. Google RE2* 2. Rust’s regex library† 3. Virtual machine approach‡ * github.com/google/re2 † github.com/rust-lang/regex ‡ swtch.com/~rsc/regexp/regexp2.html
  • 18. MOV CX, 10 MOV AX, [BP] L: CMP CX, 0 JZ E SHL AX, 1 DEC CX JMP L E: RET Machine code (actually, assembly) AX 123 BX 234 CX 9 ... IP 0 Registers Crude example of an x86 machine
  • 19. MOV CX, 10 MOV AX, [BP] L: CMP CX, 0 JZ E SHL AX, 1 DEC CX JMP L E: RET Machine code (actually, assembly) AX 123 BX 234 CX 9 ... IP 0 Thread 1 Registers AX 321 BX 432 CX 0 ... IP 7 Thread 2 Registers AX 879 BX 567 CX 4 ... IP 3 Thread 3 Registers Crude example of an x86 machine
  • 20. MOV CX, 10 MOV AX, [BP] L: CMP CX, 0 JZ E SHL AX, 1 DEC CX JMP L E: RET Machine code (actually, assembly) AX 123 BX 234 CX 9 ... IP 0 Thread 1 Registers Thread 2 Registers AX 321 BX 432 CX 0 ... IP 7 Crude example of a virtual machine
  • 21. Examples of virtual machines 1. VirtualBox/VMWare/KVM 2. Java Virtual Machine 3. Domain-specific VMs
  • 22. TrexVM (Token RegEX Virtual Machine) ● Consumes input sequence token by token. ○ Never goes back to previous tokens. ● IP (instruction pointer) tracks the currently executed instruction. ● Instructions: ○ CMP x Compare current token to x, increment IP if equal, fail if not. ○ JUMP label Unconditionally set IP to the point designated by label. ○ FORK label Increment IP and spawn additional thread that jumps to label.
  • 23. TrexVM (Token RegEX Virtual Machine) ● All threads are executed in a lock-step. ○ Execute all CMP instructions simultaneously. ○ If some threads point not to CMP, statically unroll them. ● Execution continues until one thread reaches the end of the program (successful match) or all threads are dead (failed match)
  • 24. TrexVM sample run aaab Input string ↑ 1→ L1: CMP a FORK L1 CMP b Program
  • 25. TrexVM sample run aaab Input string ↑1→ L1: CMP a FORK L1 CMP b Program
  • 26. TrexVM sample run aaab Input string ↑ 1→ 2→ L1: CMP a FORK L1 CMP b Program
  • 27. TrexVM sample run aaab Input string ↑2→ L1: CMP a FORK L1 CMP b Program
  • 28. TrexVM sample run aaab Input string ↑ 2→ 3→ L1: CMP a FORK L1 CMP b Program
  • 29. TrexVM sample run aaab Input string ↑3→ L1: CMP a FORK L1 CMP b Program
  • 30. TrexVM sample run L1: CMP a FORK L1 CMP b Program aaab Input string ↑ 3→ 4→
  • 31. TrexVM sample run aaab Input string ↑ 3→ Success! L1: CMP a FORK L1 CMP b Program
  • 32. TrexVM sample run aaab Input string ↑ 3→ Success! Regex: a+b L1: CMP a FORK L1 CMP b Program
  • 33. TrexVM FORK L1 CMP a L1: FORK L2 CMP b JUMP L1 L2: CMP c Guess the regular expression:
  • 34. TrexVM FORK L1 CMP a L1: FORK L2 CMP b JUMP L1 L2: CMP c Regex: a?b*c Guess the regular expression:
  • 35. TrexVM: next iteration Added support for match groups. Each thread now has a register bank (beyond just IP register). New instructions: ● SAVEL group — save current position in input as beginning of group. ● SAVER group — save current position in input as ending of group. ● FORKSTAY label — FORK which gives the staying thread a higher priority. ● FORKJUMP label — FORK which gives the jumping thread a higher priority. Matching stops when the thread with the highest priority succeeds.
  • 36. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst snd T1 1→
  • 37. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→
  • 38. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→
  • 39. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ 2→ Reg L R fst 0 snd T2
  • 40. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ 2→ Reg L R fst 0 1 snd T2
  • 41. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ 2→ Reg L R fst 0 1 snd 1 T2
  • 42. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→
  • 43. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ 2→ Reg L R fst 0 snd T2
  • 44. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ Reg L R fst 0 2 snd T2 2→
  • 45. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 1→ Reg L R fst 0 2 snd 2 T2 2→
  • 46. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 Reg L R fst 0 2 snd 2 T2 2→ 1→
  • 47. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 Reg L R fst 0 snd T2 1→ 2→ 3→ Reg L R fst 0 2 snd 2 3 T3
  • 48. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 Reg L R fst 0 3 snd T2 1→ 3→ Reg L R fst 0 2 snd 2 3 T3 2→
  • 49. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers Reg L R fst 0 snd T1 Reg L R fst 0 3 snd 3 T2 1→ 3→ Reg L R fst 0 2 snd 2 3 T3 2→
  • 50. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers 3→ Reg L R fst 0 2 snd 2 3 T3 Success! Match groups: fst: aa snd: b
  • 51. SAVEL fst L1: CMP [ab] FORKJUMP L1 SAVER fst SAVEL snd CMP b SAVER snd Program aab Input string ↑ TrexVM1.1 sample run Thread registers 3→ Reg L R fst 0 2 snd 2 3 T3 Success! Match groups: fst: aa snd: b Regex: ([ab]+)(b)
  • 53. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string ↑ TrexVM1.1 second run Thread registers Reg L R fst snd T1 1→
  • 54. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string ↑ TrexVM1.1 second run Thread registers Reg L R fst 0 snd T1 1→
  • 55. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string ↑ TrexVM1.1 second run Thread registers Reg L R fst 0 snd T1 1→
  • 56. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 snd T1 1→ 2→ ↑ Reg L R fst 0 snd T2
  • 57. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd T1 1→ 2→ ↑ Reg L R fst 0 snd T2
  • 58. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 T1 1→ 2→ ↑ Reg L R fst 0 snd T2
  • 59. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 T1 1→ 2→ ↑ Reg L R fst 0 1 snd 1 T2 3→ Reg L R fst 0 snd T3
  • 60. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 T1 1→ 2→ ↑ Reg L R fst 0 1 snd 1 1 T2
  • 61. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 T1 1→ 2→ ↑ Reg L R fst 0 1 snd 1 1 T2
  • 62. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 2 T1 1→ ↑
  • 63. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 2 T1 1→ ↑ Success! Match groups: fst: a snd: b
  • 64. SAVEL fst L1: CMP [ab] FORKSTAY L1 SAVER fst SAVEL snd FORKSTAY L2 CMP b L2: SAVER snd Program ab Input string TrexVM1.1 second run Thread registers Reg L R fst 0 1 snd 1 2 T1 1→ ↑ Success! Match groups: fst: a snd: b Regex: ([ab]+?)(b?)
  • 66. Concatenation #INCLUDE regex1 #INCLUDE regex2 ... #INCLUDE regexN (cat regex1 regex2 … regexN)
  • 67. Quantifiers #LABEL _LOOP #INCLUDE regex FORKJUMP _LOOP (+ regex) #LABEL _LOOP #INCLUDE regex FORKSTAY _LOOP (+? regex)
  • 68. Quantifiers #LABEL _START FORKSTAY _END #INCLUDE regex JUMP _START #LABEL _END (* regex) #LABEL _START FORKJUMP _END #INCLUDE regex JUMP _START #LABEL _END (*? regex)
  • 69. Quantifiers FORKSTAY _SKIP #INCLUDE regex #LABEL _SKIP (? regex) FORKJUMP _SKIP #INCLUDE regex #LABEL _SKIP (?? regex)
  • 70. Alternation FORKSTAY _ALT #INCLUDE regex1 JUMP _END #LABEL _ALT #INCLUDE regex2 #LABEL _END (| regex1 regex2)
  • 71. Match groups SAVEL name #INCLUDE regex SAVER name (as group regex)
  • 72. Possible CMP arguments ● String (check if token is equal) ● Char-level regex (check if token matches) ● Hashset/map (check if it contains the token) ● Arbitrary predicate (check if token satisfies)
  • 73. TrexVM syntax (as :person (| (cat (? is-honorific) (+ first-name-dict) last-name-dict)) (cat (? is-determiner) profession-dict)) Now we can write regular expressions like this:
  • 74. Extra features (cat (+ name-dict) (?! is-stop-word)) Negative and positive (nested) look aheads
  • 75. Extra features (cat (+ name-dict) (?! is-stop-word)) Negative and positive (nested) look aheads Implemented as a subvirtual machine inside each thread.
  • 76. Start/end of sequence anchors (^ and $) (cat < is-number (? is-word) >) Extra features
  • 77. Extra features (cat (*? .) regex…) Cheap anchor-free macthing
  • 78. Loop detection (rx-find (cat (* (| a (cat a a))) b) (repeat 300 a)) => nil Extra features
  • 79. Composability (def numbered-street-name (+ (| is-ordinal-number street-name-dict)) (def street (| (cat (? #"d+") numbered-street-name street-marker-dict) (cat #"d+" numbered-street-name #{"Count" "Drive"})) Extra features
  • 80. Shortcomings ● No look-behinds ● No backreferences ● Can’t find all matches (only first match) ● Overkill complexity for trivial cases
  • 82. Naive implementation ● 300 lines of Clojure ● Immutable VM and Thread objects ● Very concise and debuggable code
  • 83. Naive implementation ● 300 lines of Clojure ● Immutable VM and Thread objects ● Very concise and debuggable code ● Slow! ○ Real-world regex scan takes ~1ms per sentence
  • 84. Optimizations Inline caching of compiled regexes.
  • 85. Bad Java regexp usage for (String sentence : sentences) { sentence.matches("^(?i[rea]lly* hard+ regex))$"); }
  • 86. Good Java regexp usage Pattern p = Pattern.compile("^(?i[rea]lly* hard+ regex))$"); for (String sentence : sentences) { p.matcher(sentence).matches(); }
  • 87. Clojure: the power of macros (for [sentence-tokens all-sentences] (find (trex (+ (? company-name)) ...) sentence-tokens))
  • 88. Optimizations Inline caching of compiled regexes. 3x performance improvement.
  • 89. Optimizations ● Started rewriting parts of the implementation into Java.
  • 90. Optimizations ● Started rewriting parts of the implementation into Java. ● Made some objects mutable.
  • 91. Optimizations ● Started rewriting parts of the implementation into Java. ● Made some objects mutable. ● Made everything mutable.
  • 92. Optimizations ● Started rewriting parts of the implementation into Java. ● Made some objects mutable. ● Made everything mutable. ● Made some things immutable again.
  • 93. ● 300 lines of Java ○ VM completely rewritten in Java. ● 300 lines of Clojure ○ Function definitions, compiler, API (find, matches, …) Final version
  • 94. ● 300 lines of Java ○ VM completely rewritten in Java. ● 300 lines of Clojure ○ Function definitions, compiler, API (find, matches, …) ● Mix of mutable and immutable objects with copy-on-write fields. Final version
  • 95. ● 300 lines of Java ○ VM completely rewritten in Java. ● 300 lines of Clojure ○ Function definitions, compiler, API (find, matches, …) ● Mix of mutable and immutable objects with copy-on-write fields. ● Performance x20 of the initial version. ○ Previous regex takes 50μs per sentence. Final version
  • 96. Future work ● Improve the performance for trivial cases. ○ More static analysis and optimization in regex compilation phase.
  • 97. Future work ● Improve the performance for trivial cases. ○ More static analysis and optimization in regex compilation phase. ● JIT compiler and branch prediction ○ Leverage runtime knowledge about often-failed CMPs in the regex.
  • 98. Future work ● Improve the performance for trivial cases. ○ More static analysis and optimization in regex compilation phase. ● JIT compiler and branch prediction ○ Leverage runtime knowledge about often-failed CMPs in the regex. ○ Make it vulnerable to Meltdown/Spectre.
  • 99. Future work ● Improve the performance for trivial cases. ○ More static analysis and optimization in regex compilation phase. ● JIT compiler and branch prediction ○ Leverage runtime knowledge about often-failed CMPs in the regex. ○ Make it vulnerable to Meltdown/Spectre. ● Investigate if look-behinds are possible (through hacks and reduced perf)
  • 100. Conclusions ● Old papers contain great ideas ● Knowledge from university can be useful ● Make it work, then make it fast
  • 101. References ● Original paper: https://swtch.com/~rsc/regexp/regexp2.html ● Open-source implementation (in Clojure): https://github.com/cgrand/seqexp ● Synacor Challenge https://challenge.synacor.com