---
title: "V is for Vvork in Progress"
date: 2020-01-03
series: v
tags:
 - constructive-criticism
---

# V is for Vvork in Progress

So, December has come and passed. I'm excited to see [V][vlang] 1.0 get released
as a stable production-ready release so I can write production applications in
it!

NOTE: I was asked to write this post after version 1.0 was released in December.

[vlang]: https://vlang.io

Looking at the [description of their github repo][v-github] over time, let's see
how things changed:

[v-github]: https://github.com/vlang/v

| Date from Archive.org         | Stable Release | Date          |
| :------------------------     | :------------- | :------------ |
| [April 24, 2019][4242019]     | Not mentioned  |               |
| [June 22, 2019][6222019]      | Implied        | June 22, 2019 |
| [June 23, 2019][6232019]      | Not mentioned  |               |
| [July 21, 2019][7212019]      | 1.0            | December 2019 |
| [September 8, 2019][9082019]  | 1.0            | December 2019 |
| [October 26, 2019][10262019]  | 1.0            | December 2019 |
| [November 19, 2019][11192019] | 0.2            | November 2019 |
| [December 4, 2019][12282019]  | 0.2            | December 2019 |

[4242019]: https://web.archive.org/web/20190424002131/https://github.com/vlang/v
[6222019]: https://web.archive.org/web/20190622113157/https://github.com/vlang/v
[6232019]: https://web.archive.org/web/20190623022543/https://github.com/vlang/v
[7212019]: https://web.archive.org/web/20190721020215/https://github.com/vlang/v
[9082019]: https://web.archive.org/web/20190908054225/https://github.com/vlang/v
[10262019]: https://web.archive.org/web/20191026164355/https://github.com/vlang/v
[11192019]: https://web.archive.org/web/20191119010047/https://github.com/vlang/v
[12282019]: https://github.com/vlang/v/commit/f0f62f62174fc041d8cd61263be31ad36d99200d#diff-04c6e90faac2675aa89e2176d2eec7d8

As of the time of writing this post, it is January third, 2020 and the roadmap
is apparently to release V 0.2 this month.

Let's see what's been fixed since [my last article](https://christine.website/blog/v-vaporware-2019-06-23).

## Compile Speed

I have gotten feedback that the metric I used for testing the compile speed
claims was an unfair benchmark. Apparently it's not reasonable to put 1.2
million printfs in the same function. I'm going to fix this by making the test a
bit more representative of real world code.

```moonscript
#!/usr/bin/env moon
-- this is Moonscript code: https://moonscript.org

with io.popen "mkdir hellomodule"
  print \read "*a"
  \close!

for i=1, 1000
  with io.open "hellomodule/file_#{i}.v", "w"
    \write "module hellomodule\n\n"
    for j=1, 1200
      \write "pub fn print_#{i}_#{j}() { println('hello, #{i} #{j}!') }\n\n"
    \close!
```

This creates 1000 files with 1200 functions in them. These numbers were derived
from the [greatest factor pairs of 1.2
million](https://www.calculatorsoup.com/calculators/math/factors.php). If V
lives up to its claims that it can build 1.2 million lines of code in a second,
this should only take one second to run:

```console
$ moon gen.moon
$ time ~/code/v/v build module $(pwd)/hellomodule/
Building module "hellomodule" (dir="/home/cadey/tmp/vmeme/moon/hellomodule")...
Generating a V header file for module `/home/cadey/tmp/vmeme/moon/hellomodule`
/home/cadey/code/v//home/cadey/tmp/vmeme/moon/hellomodule
Building /home/cadey/.vmodules//home/cadey/tmp/vmeme/moon/hellomodule.o...
599.37user 13.35system 10:16.92elapsed 99%CPU (0avgtext+0avgdata 17059740maxresident)k
0inputs+2357808outputs (0major+7971041minor)pagefaults 0swaps
```

It took over 10 minutes to compile 1.2 million lines of code. 
Some interesting statistics about this run:

- GCC's oom score from the kernel task scheduler topped out at over 496
- GCC used over 16 GB of ram
- The V compiler used over 3 GB of ram
- This is an average of 2000 lines of code per second!

As of [the time of writing this article][citation-speed], the main V website
mentions that the compiler should handle 100,000 lines of code per second, or
that it should compile code approximately 500 times as fast as it does currently.

[citation-speed]: https://web.archive.org/web/20200103172957/https://vlang.io/

This does not seem to be the case. It would be nice if the V author could
clarify how he got his benchmarks and make his process public. Here's the
`/proc/cpuinfo` of the machine I ran this test on:

```
processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 58
model name      : Intel(R) Xeon(R) CPU E3-1245 V2 @ 3.40GHz
stepping        : 9
microcode       : 0x20
cpu MHz         : 1596.375
cache size      : 8192 KB
physical id     : 0
siblings        : 8
core id         : 0
cpu cores       : 4
apicid          : 0
initial apicid  : 0
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca 
                  cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm
                  pbe syscall nx rdtscp lm constant_tsc arch_perfmon pebs bts 
                  rep_good nopl xtopology nonstop_tsc cpuid aperfmperf pni
                  pclmulqdq dtes64 monitor ds_cpl vmx smx est tm2 ssse3 cx16 
                  xtpr pdcm pcid sse4_1 sse4_2 x2apic popcnt tsc_deadline_timer
                  aes xsave avx f16c rdrand lahf_lm cpuid_fault pti ssbd ibrs 
                  ibpb stibp tpr_shadow vnmi flexpriority ept vpid fsgsbase 
                  smep erms xsaveopt dtherm ida arat pln pts flush_l1d
bugs            : cpu_meltdown spectre_v1 spectre_v2 spec_store_bypass l1tf
bogomips        : 6784.45
clflush size    : 64
cache_alignment : 64
address sizes   : 36 bits physical, 48 bits virtual
power management:
```

The resulting object file is 280 MB (surprising given the output of the
generator script was only 67 MB).

```console
$ cd ~/.vmodules/home/cadey/tmp/vmeme/moon/

$ ls
hellomodule.o

$ du -hs hellomodule.o
280M    hellomodule.o
```

Let's see how big the resulting binary is for calling one of these functions:

```
// main.v
import mymodule

fn main() {
  mymodule.print_1_1()
}
```

```console
$ ~/code/v/v build main.v
main.v:1:14: cannot import module "mymodule" (not found)
    1| import mymodule
                    ^
    2|
    3| fn main() {
```

...oh dear. Can someone file this as an issue for me? I was following the directions
[here](https://vlang.io/docs#modules) and I wasn't able to get things working. I can't
open issues myself because I've been banned from the V issue tracker, or I would have
already.

Can we recover this with gcc? Let's get the symbol name with `nm(1)`:

```console
$ nm hellomodule.o  | grep print_1_1'$'
0000000000000000 T hellomodule__print_1_1
```

So the first print function is exported as `hellomodule__print_1_1`, and it was
declared as:

```v
pub fn print_1_1() { println('hello, 1 1!') }
```

This means we should be able to declare/use it like we would a normal C function
that returns void and without arguments:

```
// main.c

void hellomodule__print_1_1();

void main__main() {
  hellomodule__print_1_1();
}
```

I copied hellomodule.o to the current working directory to test this. I also
used the C output of the `hello world` program below and replaced the
`main__main` function with a forward declaration. I called this
[hello.c](https://clbin.com/7Yisp). This is a very horrible no good hack but
it worked enough to pass the linker's muster. Not doing this caused this
[shower of linker errors](https://twitter.com/theprincessxena/status/1213161054777331713).

```console
$ gcc -o main.o -c main.c
$ gcc -o hello.o -c hello.c
$ gcc -o main hellomodule.o main.o hello.o
$ ./main
hello, 1 1!

$ du -hs main
179M    main
```

Yikes. Let's see if we can reduce the binary size at all. `strip(1)` usually
helps with this:

```console
$ strip main
$ du -hs main
121M    main
```

Well that's a good chunk of it shaved off at least. It looks like there's no
dead code elimination at play. This probably explains why the binary is so big.

```console
$ strings main | grep hello | wc -l
1200000
```

Yep! It has all the strings. That's gonna be big no matter what you do. Maybe there
could be some clever snipping of things, but it's reasonable for that to not happen
by default.

## Hello World Leak

One of the things I noted in my last post was that the Hello world program
leaked memory. Let's see if this still happens:

```
// hello.v
fn main() {
        println('Hello, world!')
}

```

```console
$ ~/code/v/v build hello.v
$ valgrind ./hello
==31465== Memcheck, a memory error detector
==31465== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==31465== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==31465== Command: ./hello
==31465==
Hello, world!
==31465==
==31465== HEAP SUMMARY:
==31465==     in use at exit: 0 bytes in 0 blocks
==31465==   total heap usage: 2 allocs, 2 frees, 2,024 bytes allocated
==31465==
==31465== All heap blocks were freed -- no leaks are possible
==31465==
==31465== For counts of detected and suppressed errors, rerun with: -v
==31465== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
```

Nice! Let's see if the compiler leaks while building it:

```console
$ valgrind ~/code/v/v build hello.v
==32295== Memcheck, a memory error detector
==32295== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==32295== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==32295== Command: /home/cadey/code/v/v build hello.v
==32295==
==32295==
==32295== HEAP SUMMARY:
==32295==     in use at exit: 4,600,383 bytes in 74,522 blocks
==32295==   total heap usage: 76,590 allocs, 2,068 frees, 6,452,537 bytes allocated
==32295==
==32295== LEAK SUMMARY:
==32295==    definitely lost: 2,372,511 bytes in 56,223 blocks
==32295==    indirectly lost: 2,210,724 bytes in 18,077 blocks
==32295==      possibly lost: 0 bytes in 0 blocks
==32295==    still reachable: 17,148 bytes in 222 blocks
==32295==         suppressed: 0 bytes in 0 blocks
==32295== Rerun with --leak-check=full to see details of leaked memory
==32295==
==32295== For counts of detected and suppressed errors, rerun with: -v
==32295== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
```

For comparison, this compile leaked `3,861,785` bytes of ram last time. This
means that the compiler has overall gained 0.8 megabytes of leak in the last 6
months. This is worrying, given that V claims to not have a garbage collector. I
can only wonder how much ram was leaked when building that giant module.

> If your V program compiles, it's guaranteed that it's going to be leak free.

Quoted [from here](https://web.archive.org/web/20200103220131/https://vlang.io/docs).

For giggles, let's see if V in module mode leaks ram somehow:

```console
$ valgrind ./main
==15483== Memcheck, a memory error detector
==15483== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==15483== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==15483== Command: ./main
==15483==
hello, 1 1!
==15483==
==15483== HEAP SUMMARY:
==15483==     in use at exit: 0 bytes in 0 blocks
==15483==   total heap usage: 2 allocs, 2 frees, 2,024 bytes allocated
==15483==
==15483== All heap blocks were freed -- no leaks are possible
==15483==
==15483== For counts of detected and suppressed errors, rerun with: -v
==15483== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
```

Nope! The hello world memory leak was actually fixed!

## Other Claims

- Vweb was shipped
- Hot code reloading was shipped
- Code translation is still vaporware
- The compiler generates direct machine code

### Code Translation

I've been really looking forward to this to see how 1:1 it can make the output.
Let's see if you can use it.

```
$ ~/code/v/v help | grep translate
  translate         Translates C to V. [wip, will be available in V 0.3]

$ ~/code/v/v translate
Translating C to V will be available in V 0.3 (January)
```

This is confusing to me given he claims that 0.2 will be out in January, but
whatever I can let this slide.

The [doom example][vdoom] is still only one file that doesn't even compile
anymore.

[vdoom]: https://github.com/vlang/doom

I really do like how it handles extern functions though, you just declare them
without bodies like C. Then it just figures things out for you. I wonder if this
works with syscall functions too.

### The Compiler Generates Direct Machine Code

In my testing I was unable to figure out how to get the V compiler to generate
direct machine code. Until an example of this is released, I am quite skeptical
of this claim.

---

Overall, V is a work in progress. It has made a lot of progress since the last
time I talked about it, but the 1.0 release promise has been shattered. If I was
going to suggest anything to the V author, don't give release dates or
timetables. This kind of thing needs to be ready when it's ready and no sooner.

Also if you are writing a compiler and posting benchmarks, please make my life
easier when trying to verify them. Put the entire repo you're using for the
benchmarks somewhere. Include the exact commands you used to collect those
benchmarks. Make it obvious how they were collected, what hardware they were run
on, etc. This stuff really helps a lot when trying to verify them. Otherwise I
have to guess, and I might get it wrong. I don't know if my benchmark is an entirely
fair one, but given the lack of information on how to replicate it it's probably
going to have to do.

> Don’t ever, ever try to lie to the Internet, because they will catch you. They
> will deconstruct your spin. They will remember everything you ever say for
> eternity.  

\- Gabe Newell
