Maciej Piechotka's Blog

Curently Vala simply generates C code and let the C compiler do its job. While in many cases it produces good code there are some cases which where compiler stack could use more domain-specific knowledge. The problem is that C was constructed as human-readable language and it’s optimization keywords are directed for writing in it directly, while Vala have more highier level knowledge and it needs to make the compiler deduce properties, which might be trivial for the code reader/writer.

For example consider the code below. This is very simple code, but the Vala compiler will treat the lambda as a full scale event. As the result instead of allocating the data on stack it will be allocated from heap. All the accesses will be done by pointer indirection after the lambda as data have escaped and evil stdout.printf might access it (for all compiler knows – it does). Furthermore the widget and this will be referenced during the cast and unreferenced afterwards – unnecessary as both values should be live the whole time.

class Test {
    void foo(Gee.List<Gtk.Widget> list) {
        double powersum = 0;
        int no = 0;
        int x = 0;
        list.foreach ((widget) => {
            no++;
            i++;
            Gtk.SpinButton? spin = widget as Gtk.SpinButton;
            if (spin != null) {
                double val = spin.get_value ();
                powersum += val * val;
                stdout.print("%d: %d, %d\n", no, powersum, x);
            }
        });
        for (int i = 0; i < 1000; i++) {
            if (x != 0) {
                stdout.printf("An error\n");
            } else {
                stdout.printf("");
            }
        }
    }
    private int i = 0;
}

Continue reading →