最終更新日：2011年3月31日

「マルチコア時代のプログラミング言語「X10」」サンプルプログラム

プログラムの利用にあたっては、情報処理学会著作権規程および倫理綱領をご一読のうえ、ご利用いただけますようお願いします。

図-2　X10 によるHello World と，その実行例


class MyHello {
   public static def main(Array[String]) {
      finish for (pl in Place.places()) {
         async at (pl) Console.OUT.println(
                       "Hello World from place " + here.id);
} } }

図-3　X10 の記法を概観するための例


import x10.util.Pair; // struct to represent a pair
public class MySample[T] {
  val data:T;
  def this(d:T) { data = d; } // constructor
  def get() = data;

  public static def main(args:Array[String](1)):void {
    /* Add from 1 to arg */
    val end = (args.size > 0) ? Int.parse(args(0)) : 10;
    var sum:Int = 0;
    for (var i:Int = 1; i <= end; i++) sum += i;
    Console.OUT.printf("Sum of 1-%d: %d\n", end, sum);

    /* Object creation with generics */
    val obj = new MySample[Double](1.2);
    Console.OUT.println(obj.get()); // -> 1.2

    /* Various data types */
    val pair = Pair[Int,Int](3,4); // struct
    val func = (i:Int,j:Int)=>i*j; // function
    Console.OUT.println(func(pair.first,pair.second)); // -> 12
  }
}

図-5　演算子のユーザ定義例

public class MyPoly(a:Int,b:Int,c:Int) { // denotes a*x^2 + b*x + c
  public def toString() = ""+a+"*x^2 + " + b+"*x + " + c;
  operator this(n:Int) = a*n*n + b*n + c;

  operator this+(p:MyPoly) = new MyPoly(a+p.a, b+p.b, c+p.c);
  static operator (p:MyPoly)*(q:MyPoly) {
    if (p.a!=0 || q.a!=0) Console.OUT.println("unsupported");
    return new MyPoly(p.b*q.b, p.b*q.c+p.c*q.b, p.c*q.c);
  }
  operator -this = new MyPoly(-a,-b,-c);
  static operator (n:Int):MyPoly = new MyPoly(0,0,n); // coercion

  public static def main(Array[String]) {
    val X = new MyPoly(0,1,0); // == 0*x^2 + 1*x + 0
    val t = -X + 3;            // -X+3
    val u = 2*X + 1;           // 2X+1
    val v = t * u;             // (-X+3)(2X+1)
    Console.OUT.println(v);    // -> -2*x^2 + 5*x + 3
    Console.OUT.println(v(2)); // -> 5
    val func = MyPoly.+;       // operator function
    Console.OUT.println(func(t,u)); // -> 0*x^2 + 1*x + 4
  }
}

図-6　構造体や関数の使用例

public struct MyPair[T,U](first:T, second:U)
                implements (String)=>String {
  public operator this(s:String) = s+"("+first+","+second+")";
  static def curry[S](f:(S,S)=>S, b:S) = (x:S)=>f(x,b);

  public static def main(Array[String]) {
    /* Struct example */
    val p = MyPair[Int,Double](1,2.3);
    Console.OUT.println(p("Data is ")); // -> Data is (1,2.3)
    val x<:Int = 4; // exact type is Int{self==4}
    val q = MyPair[(Int)=>Int, Int]((i:Int)=>i*x, 5);
    Console.OUT.println(q.first(q.second)); // -> 20
    var a:Any = p;
    Console.OUT.println(a.typeName());
                // -> MyPair[x10.lang.Int,x10.lang.Double]

    /* Function example */
    val power = Math.pow.(Double,Double); // method selector
    Console.OUT.println(power(2,5)); // -> 32.0
    val square = curry[Double](power, 2);
    Console.OUT.println(square(5)); // -> 25.0

    val sq = (n:Int)=>{
                var s:Int=0; val abs_n = n<0 ? -n : n;
                for ([i] in 1..abs_n) s+=abs_n;
                s // return value of the closure
             };
    Console.OUT.println(sq(5)); // -> 25
  }
}

図-8　配列の使用例

public class MyAssoc[T] { // simple associative array
  val map = new x10.util.HashMap[String,T]();
  operator this(key:String)=(value:T) = map.put(key, value);
  operator this(key:String) = map.getOrThrow(key);

  public static def main(Array[String]) {
    /* Array-like access */
    val aa = new MyAssoc[Int]();
    aa("one") = 1;             // ==operator this("one")=1
    aa("two") = 1 + aa("one"); // ==operator this("one")
    Console.OUT.println(aa("two")); // -> 2

    /* Basic array example */
    val arr = new Array[Int](1000);
    for ([i] in 1..arr.size) arr(i-1) = i;
    var s:Int = 0;
    for (pt in arr) s += arr(pt)*arr(pt);
    Console.OUT.println(s); // -> 333833500

    /* Point */
    val pt1 = [1,3,7] as Point;       // rank==3
    Console.OUT.println(pt1(1));      // -> 3
    val [a,b,c] = pt1;                // a==1, b==3, c==7
    val pt2[x,y] = Point.make(1,3);   // x==1, y==3
    Console.OUT.println(pt2); // -> [1,3]

    /* Region */
    val R1 = 3..5; // rank==1
    val R2 = (-1..1)*R1; // rank==2
    Console.OUT.println(pt2 in R2); // -> true

    /* Array */
    val arr1 = new Array[Int](R2, ([i,j]:Point)=>i*j);
    Console.OUT.println(arr1(pt2));    // -> 3
    Console.OUT.println(arr1(-1,4));   // -> -4
  }
}

図-9　アクティビティとプレースの使用例

public class MyFib {
  var r:Int; // in-out parameter
  def this(i:Int) { r = i; }
  def run() {
    if (r < 2) return r; // MyFib(0)==0, MyFib(1)==1
    val f1 = new MyFib(r-1), f2 = new MyFib(r-2);
    finish {
      async f1.run(); // compute MyFib(r-1) in parallel
            f2.run(); // compute MyFib(r-2) by myself
    }
    return (r = f1.r + f2.r); // MyFib(r-1) + MyFib(r-2)
  }

  public static def main(args:Array[String](1)) {
    /* Compute a Fibonacci number in parallel */
    val n = (args.size>0)? Int.parse(args(0)) : 10;
    val f = new MyFib(n); f.run();
    Console.OUT.println("Fib("+n+")="+f.r); // -> Fib(10)=55

    /* Place shift */
    Console.OUT.println(Place.MAX_PLACES); // -> 4 (etc.)
    val r = at (here.next()) new MyFib(10).run();
    Console.OUT.println(r);   // -> 55

    /* Local variable access */
    var m:Int = 0; // mutable
    val i = 1;                // immutable
    finish async { m = i; }   // ok
    Console.OUT.println(m);   // -> 1
    val h = here;
    at (here.next()) {
      Console.OUT.println(i); // -> 1
      // m = 2;               // compile error
      at (h) m = 2;           // ok
    }
    Console.OUT.println(m);   // -> 2

    /* Object and GlobalRef */
    val o = new MyFib(0);
    at (here.next()) o.r = 1; // copy of o is modified
    Console.OUT.println(o.r); // -> 0
    val g = GlobalRef[MyFib](o);
    at (here.next()) { at (g.home) g().r = 2; }
    Console.OUT.println(o.r); // -> 2
  }
}

図-10　排他・同期制御の例

public class MyBuf {
  var datum:Int = 0, filled:Boolean = false;
  def send(v:Int) {
    when (!filled) { filled = true; datum = v; }
  }
  def receive():Int {
    when ( filled) { filled = false; return datum; }
  }
  static atomic def say(s:String) = Console.OUT.println(s);

  public static def main(Array[String]) {
    /* Atomic block */
    var s:Int = 0;
    finish for ([i] in 1..1000) async {
      val tmp = i*i; atomic { s += tmp; }
    }
    Console.OUT.println(s); // -> 333833500

    /* Conditional atomic blocks */
    val buf = new MyBuf();
    finish {
      for ([i] in 0..9) async buf.send(i); // senders
      for ([i] in 0..9) Console.OUT.print(buf.receive());
      Console.OUT.println(); // -> 0217635489 (etc.)
    }

    /* Clocked execution */
    clocked finish {
      clocked async { // clocked activity A
        say("A-1 "); next;
        say(" A-2"); next;
        say("A-3 ");
      }
      clocked async { // clocked activity B
        System.sleep(1000); // sleep 1 sec
        say("B-1 "); next;
        say(" B-2"); next;
        say("B-3 ");
      }
      clocked async { // clocked activity C
        for ([i] in 1..3) {
          val spc = (i%2==0) ? " " : "";
          say(spc + "C-" + i); next;
    } } }
} }

図-11　分散配列の使用例

public class MyDist {
  public static def main(Array[String]) {
    /* Dist */
    val D1 = Dist.makeBlock(0..9);
                // (0..2)->0 (3..5)->1 (6..7)->2 (8..9)->3
    Console.OUT.println(D1(3)); // -> (Place 1)
    val D2 = D1 | here; // (0)->0 (1)->0 (2)->0
    val D3 = D1 | 2..4; // (2)->0 (3)->1 (4)->1
    val D4 = 0..9->here; // (0..9)->0
    val D5 = Dist.makeUnique(); // (0)->0 (1)->1 (2)->2 (3)->3

    /* DistArray */
    val R = (1..4)*(5..6);
    val D = Dist.makeBlock(R); Console.OUT.println(D);
    val da = DistArray.make[Int](D, ([i,j]:Point)=>i*j);
    for (pt in da)
      Console.OUT.println(at (da.dist(pt)) da(pt));

    /* Advanced DistArray example */
    val D0 = Dist.makeBlock(1..1000);
    val da0 = DistArray.make[Int](D0, ([i]:Point)=>i);
    val places = da0.dist.places(); // Sequence[Place]
    val tmp = new Array[Int](places.size);
    finish for ([i] in 0..(places.size-1)) async {
      tmp(i) = at (places(i)) {
                val a = da0 | here; // restriction
                var s:Int = 0;
                for (pt in a) s += a(pt)*a(pt);
                s // return value of at
              };
    }
    var s0:Int = 0; for (pt in tmp) s0 += tmp(pt);
    Console.OUT.println(s0); // -> 333833500

    /* DistArray.map and reduce */
    val s1 = da0.map((i:Int)=>i*i).reduce(Int.+, 0);
    Console.OUT.println(s1); // -> 333833500
  }
}