X10

Support for inlining final methods with C++ back-end

Details

  • Number of attachments :
    0

Description

Performance of many things in the X10 library depends on inlining final methods. Currently this isn't happening in C++ back-end. The following need to be done:

1. Ensure (at least final) method bodies are in .h files. (This is currently the case for generics, which is also the case for which inlining peformance is most critical, so for an initial implementation nothing needs to be done for this requirement).

2. Declare the method bodies with the "inline" keyword.

3. Use non-virtual calls o->C::m for calls to final methods.

Activity

Ascending order - Click to sort in descending order
Hide
Permalink
Dave Cunningham added a comment - - edited

Part 3 is complete, I got these results with the following program, if they are sufficient we can make the remaining tasks a 1.7.4 bug otherwise I will continue work.

Rail: initialise = 0.131934644
Rail: work = 0.127145883
RailWrapper: initialise = 0.443303999
RailWrapper: work = 0.537448934
FinalRailWrapper: initialise = 0.111745609
FinalRailWrapper: work = 0.137191966
FinalFieldsRailWrapper: initialise = 0.119469072
FinalFieldsRailWrapper: work = 0.121270821

-O3 -mtune=native -march=native -DNO_CHECKS

g++ (Ubuntu 4.3.2-1ubuntu11) 4.3.2
Linux lenin 2.6.27-9-generic #1 SMP Thu Nov 20 21:57:00 UTC 2008 i686 GNU/Linux

import x10.io.Console;

class RailWrapper[T] implements (Int)=>T {
    public static def makeVar[T](length:Int) = new RailWrapper[T](length);
    var wrapped : Rail[T];
    val length : Int;
    public def this (length:Int) {
        wrapped = Rail.makeVar[T](length);
        this.length = length;
    }
    public def apply (index:Int) {
        return wrapped(index);
    }
    public def set (v:T, index:Int) {
        wrapped(index) = v;
    }
}
    
final class FinalRailWrapper[T] implements (Int)=>T {
    public static def makeVar2[T](length:Int) = new FinalRailWrapper[T](length);
    var wrapped : Rail[T];
    val length : Int;
    public def this (length:Int) {
        wrapped = Rail.makeVar[T](length);
        this.length = length;
    }
    public def apply (index:Int) {
        return wrapped(index);
    }
    public def set (v:T, index:Int) {
        wrapped(index) = v;
    }
}

class FinalFieldsRailWrapper[T] implements (Int)=>T {
    public static def makeVar2[T](length:Int) = new FinalFieldsRailWrapper[T](length);
    var wrapped : Rail[T];
    val length : Int;
    public def this (length:Int) {
        wrapped = Rail.makeVar[T](length);
        this.length = length;
    }
    public final def apply (index:Int) {
        return wrapped(index);
    }
    public final def set (v:T, index:Int) {
        wrapped(index) = v;
    }
}

public class InlineTest {
    public static def do_test[T] (name:String, rail:T) {
    }

    public static def main (args : Rail[String]) {
        val sz = 20 * 1000000; // for doubles this is 160MB
        {
            val rail = Rail.makeVar[Double](sz);
            val t1 = System.nanoTime();
            for (var i:Int=0 ; i<rail.length ; ++i) {
                rail(i) = i;
            }
            val t2 = System.nanoTime();
            for (var i:Int=0 ; i<rail.length ; ++i) {
                rail(i) = rail(i) / 2;
            }
            val t3 = System.nanoTime();
            Console.OUT.println("Rail: initialise = "+(t2-t1)/1E9);
            Console.OUT.println("Rail: work = "+(t3-t2)/1E9);
        }

        {
            val rail = RailWrapper.makeVar[Double](sz);
            val t1 = System.nanoTime();
            for (var i:Int=0 ; i<rail.length ; ++i) {
                rail(i) = i;
            }
            val t2 = System.nanoTime();
            for (var i:Int=0 ; i<rail.length ; ++i) {
                rail(i) = rail(i) / 2;
            }
            val t3 = System.nanoTime();
            Console.OUT.println("RailWrapper: initialise = "+(t2-t1)/1E9);
            Console.OUT.println("RailWrapper: work = "+(t3-t2)/1E9);
        }

        {
            val rail = FinalRailWrapper.makeVar2[Double](sz);
            val t1 = System.nanoTime();
            for (var i:Int=0 ; i<rail.length ; ++i) {
                rail(i) = i;
            }
            val t2 = System.nanoTime();
            for (var i:Int=0 ; i<rail.length ; ++i) {
                rail(i) = rail(i) / 2;
            }
            val t3 = System.nanoTime();
            Console.OUT.println("FinalRailWrapper: initialise = "+(t2-t1)/1E9);
            Console.OUT.println("FinalRailWrapper: work = "+(t3-t2)/1E9);
        }

        {
            val rail = FinalFieldsRailWrapper.makeVar2[Double](sz);
            val t1 = System.nanoTime();
            for (var i:Int=0 ; i<rail.length ; ++i) {
                rail(i) = i;
            }
            val t2 = System.nanoTime();
            for (var i:Int=0 ; i<rail.length ; ++i) {
                rail(i) = rail(i) / 2;
            }
            val t3 = System.nanoTime();
            Console.OUT.println("FinalFieldsRailWrapper: initialise = "+(t2-t1)/1E9);
            Console.OUT.println("FinalFieldsRailWrapper: work = "+(t3-t2)/1E9);
        }
    }
}
Show
Dave Cunningham added a comment - - edited Part 3 is complete, I got these results with the following program, if they are sufficient we can make the remaining tasks a 1.7.4 bug otherwise I will continue work. Rail: initialise = 0.131934644 Rail: work = 0.127145883 RailWrapper: initialise = 0.443303999 RailWrapper: work = 0.537448934 FinalRailWrapper: initialise = 0.111745609 FinalRailWrapper: work = 0.137191966 FinalFieldsRailWrapper: initialise = 0.119469072 FinalFieldsRailWrapper: work = 0.121270821 -O3 -mtune=native -march=native -DNO_CHECKS g++ (Ubuntu 4.3.2-1ubuntu11) 4.3.2 Linux lenin 2.6.27-9-generic #1 SMP Thu Nov 20 21:57:00 UTC 2008 i686 GNU/Linux import x10.io.Console; class RailWrapper[T] implements (Int)=>T { public static def makeVar[T](length:Int) = new RailWrapper[T](length); var wrapped : Rail[T]; val length : Int; public def this (length:Int) { wrapped = Rail.makeVar[T](length); this .length = length; } public def apply (index:Int) { return wrapped(index); } public def set (v:T, index:Int) { wrapped(index) = v; } } final class FinalRailWrapper[T] implements (Int)=>T { public static def makeVar2[T](length:Int) = new FinalRailWrapper[T](length); var wrapped : Rail[T]; val length : Int; public def this (length:Int) { wrapped = Rail.makeVar[T](length); this .length = length; } public def apply (index:Int) { return wrapped(index); } public def set (v:T, index:Int) { wrapped(index) = v; } } class FinalFieldsRailWrapper[T] implements (Int)=>T { public static def makeVar2[T](length:Int) = new FinalFieldsRailWrapper[T](length); var wrapped : Rail[T]; val length : Int; public def this (length:Int) { wrapped = Rail.makeVar[T](length); this .length = length; } public final def apply (index:Int) { return wrapped(index); } public final def set (v:T, index:Int) { wrapped(index) = v; } } public class InlineTest { public static def do_test[T] (name: String , rail:T) { } public static def main (args : Rail[ String ]) { val sz = 20 * 1000000; // for doubles this is 160MB { val rail = Rail.makeVar[ Double ](sz); val t1 = System .nanoTime(); for ( var i:Int=0 ; i<rail.length ; ++i) { rail(i) = i; } val t2 = System .nanoTime(); for ( var i:Int=0 ; i<rail.length ; ++i) { rail(i) = rail(i) / 2; } val t3 = System .nanoTime(); Console.OUT.println( "Rail: initialise = " +(t2-t1)/1E9); Console.OUT.println( "Rail: work = " +(t3-t2)/1E9); } { val rail = RailWrapper.makeVar[ Double ](sz); val t1 = System .nanoTime(); for ( var i:Int=0 ; i<rail.length ; ++i) { rail(i) = i; } val t2 = System .nanoTime(); for ( var i:Int=0 ; i<rail.length ; ++i) { rail(i) = rail(i) / 2; } val t3 = System .nanoTime(); Console.OUT.println( "RailWrapper: initialise = " +(t2-t1)/1E9); Console.OUT.println( "RailWrapper: work = " +(t3-t2)/1E9); } { val rail = FinalRailWrapper.makeVar2[ Double ](sz); val t1 = System .nanoTime(); for ( var i:Int=0 ; i<rail.length ; ++i) { rail(i) = i; } val t2 = System .nanoTime(); for ( var i:Int=0 ; i<rail.length ; ++i) { rail(i) = rail(i) / 2; } val t3 = System .nanoTime(); Console.OUT.println( "FinalRailWrapper: initialise = " +(t2-t1)/1E9); Console.OUT.println( "FinalRailWrapper: work = " +(t3-t2)/1E9); } { val rail = FinalFieldsRailWrapper.makeVar2[ Double ](sz); val t1 = System .nanoTime(); for ( var i:Int=0 ; i<rail.length ; ++i) { rail(i) = i; } val t2 = System .nanoTime(); for ( var i:Int=0 ; i<rail.length ; ++i) { rail(i) = rail(i) / 2; } val t3 = System .nanoTime(); Console.OUT.println( "FinalFieldsRailWrapper: initialise = " +(t2-t1)/1E9); Console.OUT.println( "FinalFieldsRailWrapper: work = " +(t3-t2)/1E9); } } }
Hide
Permalink
Bruce Lucas added a comment -

This may be the best approach. -O3 imples -finline-functions which should inline functions that are "small enough".

We might also want to support an inline X10 keyword that would translate to an inline annotation on the method in C++ which I guess could override the size limitiation on inlining, if the developer determines that that is better.

Show
Bruce Lucas added a comment - This may be the best approach. -O3 imples -finline-functions which should inline functions that are "small enough". We might also want to support an inline X10 keyword that would translate to an inline annotation on the method in C++ which I guess could override the size limitiation on inlining, if the developer determines that that is better.

People

  • Assignee:
    Dave Cunningham
    Reporter:
    Bruce Lucas
Vote (0)
Watch (0)

Dates

  • Created:
    Updated:
    Resolved: