logo

drewdevault.com

[mirror] blog and personal website of Drew DeVault git clone https://hacktivis.me/git/mirror/drewdevault.com.git

Slow.md (9977B)

    

  1. ---
  2. date: 2020-01-04
  3. layout: basic
  4. title: Hello world
  5. ---
  7. Let's say you ask your programming language to do the simplest possible task:
  8. print out "hello world". Generally this takes two syscalls: write and exit.
  9. The following assembly program is the ideal Linux x86_64 program for this
  10. purpose. A perfect compiler would emit this hello world program for any
  11. language.
  13. ```
  14. bits 64
  15. section .text
  16. global _start
  17. _start:
  18. 	mov rdx, len
  19. 	mov rsi, msg
  20. 	mov rdi, 1
  21. 	mov rax, 1
  22. 	syscall
  24. 	mov rdi, 0
  25. 	mov rax, 60
  26. 	syscall
  28. section .rodata
  29. msg: db "hello world", 10
  30. len: equ $-msg
  31. ```
  33. Most languages do a whole lot of other crap other than printing out "hello
  34. world", even if that's all you asked for.
  36. <table class="table table-bordered">
  37.   <thead>
  38.     <tr>
  39.       <th>Test case</th>
  40.       <th>Source</th>
  41.       <th>Execution time</th>
  42.       <th>Total syscalls</th>
  43.       <th>Unique syscalls</th>
  44.       <th>Size (KiB)</th>
  45.     </tr>
  46.   </thead>
  47.   <tbody>
  48.     <tr>
  49.       <td><strong>Assembly</strong> (x86_64)</td>
  50.       <td>
  51.         <a href="#tests">test.S</a>
  52.       </td>
  53.       <td>0.00s real</td>
  54.       <td>2</td>
  55.       <td>2</td>
  56.       <td>8.6 KiB*</td>
  57.     </tr>
  58.     <tr>
  59.       <td><strong>Zig</strong> (small)</td>
  60.       <td>
  61.         <a href="#testzig">test.zig</a>
  62.       </td>
  63.       <td>0.00s real</td>
  64.       <td>2</td>
  65.       <td>2</td>
  66.       <td>10.3 KiB</td>
  67.     </tr>
  68.     <tr>
  69.       <td><strong>Zig</strong> (safe)</td>
  70.       <td>
  71.         <a href="#testzig">test.zig</a>
  72.       </td>
  73.       <td>0.00s real</td>
  74.       <td>3</td>
  75.       <td>3</td>
  76.       <td>11.3 KiB</td>
  77.     </tr>
  78.     <tr>
  79.       <td><strong>C</strong> (musl, static)</td>
  80.       <td>
  81.         <a href="#testc">test.c</a>
  82.       </td>
  83.       <td>0.00s real</td>
  84.       <td>5</td>
  85.       <td>5</td>
  86.       <td>95.9 KiB</td>
  87.     </tr>
  88.     <tr>
  89.       <td><strong>C</strong> (musl, dynamic)</td>
  90.       <td>
  91.         <a href="#testc">test.c</a>
  92.       </td>
  93.       <td>0.00s real</td>
  94.       <td>15</td>
  95.       <td>9</td>
  96.       <td>602 KiB</td>
  97.     </tr>
  98.     <tr>
  99.       <td><strong>C</strong> (glibc, static*)</td>
  100.       <td>
  101.         <a href="#testc">test.c</a>
  102.       </td>
  103.       <td>0.00s real</td>
  104.       <td>11</td>
  105.       <td>9</td>
  106.       <td>2295 KiB</td>
  107.     </tr>
  108.     <tr>
  109.       <td><strong>C</strong> (glibc, dynamic)</td>
  110.       <td>
  111.         <a href="#testc">test.c</a>
  112.       </td>
  113.       <td>0.00s real</td>
  114.       <td>65</td>
  115.       <td>13</td>
  116.       <td>2309 KiB</td>
  117.     </tr>
  118.     <tr>
  119.       <td><strong>Rust</strong></td>
  120.       <td>
  121.         <a href="#testrs">test.rs</a>
  122.       </td>
  123.       <td>0.00s real</td>
  124.       <td>123</td>
  125.       <td>21</td>
  126.       <td>244 KiB</td>
  127.     </tr>
  128.     <tr>
  129.       <td><strong>Crystal</strong> (static)</td>
  130.       <td>
  131.         <a href="#testcr">test.cr</a>
  132.       </td>
  133.       <td>0.00s real</td>
  134.       <td>144</td>
  135.       <td>23</td>
  136.       <td>935 KiB</td>
  137.     </tr>
  138.     <tr>
  139.       <td><strong>Go</strong> (static w/o cgo)</td>
  140.       <td>
  141.         <a href="#testgo">test.go</a>
  142.       </td>
  143.       <td>0.00s real</td>
  144.       <td>152</td>
  145.       <td>17</td>
  146.       <td>1661 KiB</td>
  147.     </tr>
  148.     <tr>
  149.       <td><strong>D</strong> (dmd)</td>
  150.       <td>
  151.         <a href="#testd">test.d</a>
  152.       </td>
  153.       <td>0.00s real</td>
  154.       <td>152</td>
  155.       <td>20</td>
  156.       <td>5542 KiB</td>
  157.     </tr>
  158.     <tr>
  159.       <td><strong>D</strong> (ldc)</td>
  160.       <td>
  161.         <a href="#testd">test.d</a>
  162.       </td>
  163.       <td>0.00s real</td>
  164.       <td>181</td>
  165.       <td>21</td>
  166.       <td>10305 KiB</td>
  167.     </tr>
  168.     <tr>
  169.       <td><strong>Crystal</strong> (dynamic)</td>
  170.       <td>
  171.         <a href="#testcr">test.cr</a>
  172.       </td>
  173.       <td>0.00s real</td>
  174.       <td>183</td>
  175.       <td>25</td>
  176.       <td>2601 KiB</td>
  177.     </tr>
  178.     <tr>
  179.       <td><strong>Go</strong> (w/cgo)</td>
  180.       <td>
  181.         <a href="#testgo">test.go</a>
  182.       </td>
  183.       <td>0.00s real</td>
  184.       <td>211</td>
  185.       <td>22</td>
  186.       <td>3937 KiB</td>
  187.     </tr>
  188.     <tr>
  189.       <td><strong>Perl</strong></td>
  190.       <td>
  191.         <a href="#testpl">test.pl</a>
  192.       </td>
  193.       <td>0.00s real</td>
  194.       <td>255</td>
  195.       <td>25</td>
  196.       <td>5640 KiB</td>
  197.     </tr>
  198.     <tr>
  199.       <td><strong>Java</strong></td>
  200.       <td>
  201.         <a href="#testjava">Test.java</a>
  202.       </td>
  203.       <td>0.07s real</td>
  204.       <td>226</td>
  205.       <td>26</td>
  206.       <td>15743 KiB</td>
  207.     </tr>
  208.     <tr>
  209.       <td><strong>Node.js</strong></td>
  210.       <td>
  211.         <a href="#testjs">test.js</a>
  212.       </td>
  213.       <td>0.04s real</td>
  214.       <td>673</td>
  215.       <td>40</td>
  216.       <td>36000 KiB</td>
  217.     </tr>
  218.     <tr>
  219.       <td><strong>Python 3</strong> (PyPy)</td>
  220.       <td>
  221.         <a href="#testpy">test.py</a>
  222.       </td>
  223.       <td>0.68s real</td>
  224.       <td>884</td>
  225.       <td>32</td>
  226.       <td>9909 KiB</td>
  227.     </tr>
  228.     <tr>
  229.       <td><strong>Julia</strong></td>
  230.       <td>
  231.         <a href="#testjl">test.jl</a>
  232.       </td>
  233.       <td>0.12s real</td>
  234.       <td>913</td>
  235.       <td>41</td>
  236.       <td>344563 KiB</td>
  237.     </tr>
  238.     <tr>
  239.       <td><strong>Python 3</strong> (CPython)</td>
  240.       <td>
  241.         <a href="#testpy">test.py</a>
  242.       </td>
  243.       <td>0.02s real</td>
  244.       <td>1200</td>
  245.       <td>33</td>
  246.       <td>15184 KiB</td>
  247.     </tr>
  248.     <tr>
  249.       <td><strong>Ruby</strong></td>
  250.       <td>
  251.         <a href="#testrb">test.rb</a>
  252.       </td>
  253.       <td>0.04s real</td>
  254.       <td>1401</td>
  255.       <td>38</td>
  256.       <td>1283 KiB</td>
  257.     </tr>
  258.   </tbody>
  259. </table>
  261. <div style="text-align: right">
  262.   <small>* See notes for this test case</small>
  263. </div>
  265. This table is sorted so that the number of syscalls goes up, because I reckon
  266. more syscalls is a decent metric for how much shit is happening that you didn't
  267. ask for (i.e. `write("hello world\n"); exit(0)`). Languages with a JIT fare much
  268. worse on this than compiled languages, but I have deliberately chosen not to
  269. account for this.
  271. These numbers are real. This is more complexity that someone has to debug, more
  272. time your users are sitting there waiting for your program, less disk space
  273. available for files which actually matter to the user.
  275. ### Environment
  277. Tests were conducted on January 3rd, 2020.
  279. - gcc 9.2.0
  280. - glibc 2.30
  281. - musl libc 1.1.24
  282. - Linux 5.4.7 (Arch Linux)
  283. - Linux 4.19.87 (vanilla, Alpine Linux) is used for musl libc tests
  284. - Go 1.13.5
  285. - Rustc 1.40.0
  286. - Zig 0.5.0
  287. - OpenJDK 11.0.5 JRE
  288. - Crystal 0.31.1
  289. - NodeJS 13.5.0
  290. - Julia 1.3.1
  291. - Python 3.8.1
  292. - PyPy 7.3.0
  293. - Ruby 2.6.4p114 (2019-10-01 rev 67812)
  294. - dmd 1:2.089.0
  295. - ldc 2:1.18.0
  296. - Perl 5.30.1
  298. For each language, I tried to write the program which would give the most
  299. generous scores without raising eyebrows at a code review. The size of all
  300. files which must be present at runtime (interpreters, stdlib, libraries, loader,
  301. etc) are included. Binaries were stripped where appropriate.
  303. This was not an objective test, this is just an approximation that I hope will
  304. encourage readers to be more aware of the consequences of their abstractions,
  305. and their exponential growth as more layers are added.
  307. ### test.S
  309. ```
  310. bits 64
  311. section .text
  312. global _start
  313. _start:
  314. 	mov rdx, len
  315. 	mov rsi, msg
  316. 	mov rdi, 1
  317. 	mov rax, 1
  318. 	syscall
  320. 	mov rdi, 0
  321. 	mov rax, 60
  322. 	syscall
  324. section .rodata
  325. msg: db "hello world", 10
  326. len: equ $-msg
  327. ```
  329. ```
  330. nasm -f elf64 test.S
  331. gcc -o test -static -nostartfiles -nostdlib -nodefaultlibs
  332. strip test: 8.6 KiB
  333. ```
  335. **Notes**
  337. - This program only works on x86_64 Linux.
  338. - The size depends on how you measure it:<br />
  339.   *Instructions + data alone*: 52 bytes<br />
  340.   *Stripped ELF*: 8.6 KiB<br />
  341.   *Manually minified ELF*: [142 bytes](http://timelessname.com/elfbin/)
  343. ### test.zig
  345. ```
  346. const std = @import("std");
  348. pub fn main() !void {
  349.     const stdout = try std.io.getStdOut();
  350.     try stdout.write("hello world\n");
  351. }
  352. ```
  354. ```
  355. # small
  356. zig build-exe test.zig --release-small --strip
  357. # safe
  358. zig build-exe test.zig --release-safe --strip
  359. ```
  361. **Notes**
  363. - Written with the assistance of Andrew Kelly (maintainer of Zig)
  365. ### test.c
  367. ```
  368. int puts(const char *s);
  370. int main(int argc, char *argv[]) {
  371.     puts("hello world");
  372.     return 0;
  373. }
  374. ```
  376. ```
  377. # dynamic
  378. gcc -O2 -o test test.c
  379. strip test
  381. # static
  382. gcc -O2 -o test -static test.c
  383. strip test
  384. ```
  386. **Notes**
  388. - glibc programs can never truly be statically linked. The size reflects this.
  390. ### test.rs
  392. ```
  393. fn main() {
  394.     println!("hello world");
  395. }
  396. ```
  398. ```
  399. rustc -C opt-levels=s test.rs
  400. ```
  402. **Notes**
  404. - The final binary is dynamically linked with glibc, which is included in the
  405.   size.
  407. ### test.go
  409. ```
  410. package main
  412. import "os"
  414. func main() {
  415.     os.Stdout.Write([]byte("hello world\n"))
  416. }
  417. ```
  419. ```
  420. # dynamic
  421. go build -o test test.go
  423. # static w/o cgo
  424. GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o test -ldflags '-extldflags "-f no-PIC -static"' -buildmode pie -tags 'osusergo netgo static_build' test.go
  425. ```
  427. Aside: it is getting way too goddamn difficult to build static Go binaries.
  429. **Notes**
  431. - The statically linked test was run on Alpine Linux with musl libc. It doesn't
  432.   link to libc in theory, but hey.
  434. ### Test.java
  436. ```
  437. public class Test {
  438.     public static void main(String[] args) {
  439.         System.out.println("hello world");
  440.     }
  441. }
  442. ```
  444. ```
  445. javac Test.java
  446. java Test
  447. ```
  449. ### test.cr
  451. ```
  452. puts "hello world\n"
  453. ```
  455. ```
  456. # Dynamic
  457. crystal build -o test test.cr
  459. # Static
  460. crystal build --static -o test test.cr
  461. ```
  463. **Notes**
  465. - The Crystal tests were run on Alpine Linux with musl libc.
  467. ### test.js
  469. ```
  470. console.log("hello world");
  471. ```
  473. ```
  474. node test.js
  475. ```
  477. ### test.jl
  479. ```
  480. println("hello world")
  481. ```
  483. ```
  484. julia test.jl
  485. ```
  487. **Notes**
  489. - Julia numbers were provided by a third party
  491. ### test.py
  493. ```
  494. print("hello world")
  495. ```
  497. ```
  498. # cpython
  499. python3 test.py
  500. # pypy
  501. pypy3 test.py
  502. ```
  504. ### test.pl
  506. ```
  507. print "hello world\n"
  508. ```
  510. ```
  511. perl test.pl
  512. ```
  514. **Notes**
  516. - Passing /dev/urandom into perl is equally likely to print "hello world"
  518. ### test.d
  520. ```
  521. import std.stdio;
  522. void main()
  523. {
  524.     writeln("hello world");
  525. }
  526. ```
  528. ```
  529. # dmd
  530. dmd -O test.d
  531. # ldc
  532. ldc -O test.d
  533. ```
  535. ### test.rb
  537. ```
  538. puts "hello world\n"
  539. ```
  541. ```
  542. ruby test.rb
  543. ```