X10lecture kawatiya 20111019 - IBM...2011/10/19 · 基本的にはJava風 – オブジェクト指向，静的な型付け – 単一継承（インタフェースは複数可）

© 2011 IBM Corporation

並列・分散プログラミング言語 X102011/10/19（水）河内谷清久仁 <[email protected]>日本アイ・ビー・エム（株）東京基礎研究所http://www.trl.ibm.com/people/kawatiya/

東京大学大学院工学系研究科

グローバルCOE特別講演（融合情報学特別講義II）

© 2011 IBM Corporation2 Programming Language X10 / Kiyokuni Kawachiya2011/10/19

並列・分散プログラミング言語X10概要：

– 最新のプロセッサでは複数の実行コアを備えた「マルチコア」が一般的になっている．しかし，多数のマルチコアCPUやGPGPUなどが相互接続された並列分散環境を活用するためのプログラミングは容易ではない．このような並列分散プログラムの生産性を向上させることを目標とした，新しいプログラミング言語がX10（エックステン）である．

– X10はいわゆるPGAS（Partitioned Global Address Space）を採用している言語族の一員であり，複数の「プレース」にまたがったデータ構造を扱える．さらに，軽量な並列タスクを生成するための「async」や分散処理のための「at」，同期のための「atomic」や「clocked」などの構文を提供している． X10の開発はオープンソースプロジェクトとして行われており，その成果はhttp://x10-lang.org/からアクセスできる．

– この講義では，X10を通して並列プログラミング環境研究（ハードウェア・システム・ソフトウェア）の最先端を解説する．

講師: 河内谷清久仁／日本アイ・ビー・エム（株）東京基礎研究所

– 日本IBM東京基礎研究所シニア・リサーチャー．Javaを中心とするプログラミング言語の研究・開発に従事．X10言語については主にJavaバックエンド部分の実装と性能向上を担当．http://www.trl.ibm.com/people/kawatiya


カバーする内容

並列・分散プログラミング言語「X10」について，言語仕様とプログラム例を中

心に解説します．また，ソフトウェア開発の実際についても紹介します．

内容

1. X10の概要

• 目的，特徴，背景，歴史，開発体制，実行環境

• プログラミングモデル，プログラム例

2. X10の言語仕様

• 基本的文法，データ型

• 特徴的な機構，並列・分散プログラミング

3. X10を試してみる

• 環境構築，X10DT4. ソフトウェア開発の実際


1. X10の概要


X10（エックステン）とは？

IBM Researchが開発している，新しい並列分散プログラミング言語

– 並列アプリケーションの生産性を向上させることが目的の一つ

米DARPAのHPCSプログラム

– High Productivity Computing Systems– 2002～2010年の9年間のプロジェクトで，ペタフロップス

クラスのスーパーコンピューターを開発する

IBMのPERCSプロジェクト

– Productive Easy-to-use Reliable Computer Systems– ハードとソフトを総合的にデザインし，並列アプリケーションの生産性を向

上させる

– 先進的なチップ技術，アーキテクチャ，OS，コンパイラ，プログラミング言語，ツールなどを統合

– PERCSシステム＝ POWER7 ＋ AIX ＋ GPFS ＋ X10 ＋・・・

HPCS: http://www.highproductivity.org/PERCS: http://www.research.ibm.com/hptools/

GPFS: General Parallel File System

DARPA: Defense Advanced Research Projects Agency 国防高等研究計画局


X10の目的と設計思想並列アプリケーションの生産性を向上させるのが目的，そのために，

– マルチコア時代のための新しいプログラミングモデルと，

– Eclipseに統合された開発ツール群を提供

背景

１スレッドの性能はもはやそう上がらないマルチコアやハイブリッドシステムの登場

– ソフトウェアの性能向上には，その並列性を上げることが必須

並列性の高いソフトウェアの開発では，生産性の高いプログラミング・モデルが重要

プログラマにどのように並列性を見せるか？

明示的な並列化は高性能だが，ハードウェアを意識したプログラミングが必要

暗黙的な並列化は生産性が高いが，高性能なプログラミングが難しい

その中間の「抽象的な並列化」が，X10の設計思想

– 並列・分散環境を隠蔽するのではなく，抽象化してプログラマに見せることで，生産性を保ちつつ高性能を達成する


PGASプログラミングモデル

Partitioned Global Address Space (PGAS)単一アドレス空間だが，複数の「プレース」に分割されている

– プレースが「局所性」を抽象化している，ヘテロでもかまわない（PPE，SPE，GPU，・・・）

データはどれかのプレースに属し，移動は起こらない

– 複数プレースにまたがるデータ構造も作成可能（各要素が特定プレースに紐付けされている）

データは同じプレースからしかアクセスできない

– データを他のプレースから「参照」することは可能

X10 ≒ PGASの概念をJava上で実現したもの

– さらに，非同期実行のサポートなどを強化 “Asynchronous PGAS (APGAS)”

Shared MemoryOpenMPなど

スレッド（プロセス）

データ（オブジェクト）

通信アドレス空間参照

Message PassingMPIなど

UPC: Unified Parallel CCAF: Co-Array Fortran

PGASUPC, CAF, X10 など

プレース0 プレース1 プレース2

リモート参照


分散配列

分散配列

不変（immutable）データ，クラス，構造体, 関数

async at at at

asyncasyncアクティビティ

（≒スレッド）

オブジェクト

アドレス空間

ローカル参照

プレース0 プレースMAX_PLACES-1・・・プレース1

リモート参照

生成

移動

PGAS：アドレス空間は複数のプレースに静的

に分割されている（不均一でもかまわない）•オブジェクトとアクティビティを保持

ただし，不変（immutable）データ

はどのプレースからもアクセス可能•暗黙的に複製される

複数プレースにまたがるデータ構造（DistArray）も作成可能

•各要素は特定のプレースに所属

オブジェクトは特定のプレースに所属•同じプレースのアクティビティからのみアクセス可能

リモートオブジェクトは「参照」可能•中身にアクセスするには，そのプレースに移動する必要

アクティビティは，プレース内で逐次動作する，非同期な実行主体（≒軽量スレッド）•プレース内に動的に生成可能（async文）- ローカルアクティビティとは同期・排他可能

•リモートプレースにも移動可能（at文）- リモートとは同期不可（終了は待てる）

X10の実行モデル


2つの基本アイデア＝ Places and Asynchrony

X10の特徴的な構文・データ構造

X10の実行モデル＝APGAS

細粒度並列処理• async S

排他制御• atomic S• when (cond) S

実行の同期• finish S• clocked

分散データ構造• Point, Region, Dist• DistArray

分散処理• at (place) S

分散配列

分散配列


async at at at



オブジェクト

アドレス空間

ローカル参照


リモート参照

生成

移動


X10によるHello WorldX10プログラム

コンパイルと実行

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);

} } }

$ x10c MyHello.x10 # コンパイル$ lsMyHello.x10 MyHello$$Main.classMyHello.java MyHello$$Closure$0.classMyHello.class

$ X10_NPLACES=4 x10 MyHello # 実行Hello World from place 3Hello World from place 0Hello World from place 1Hello World from place 2

C++ back-endを使う場合の例$ x10c++ -o MyHello MyHello.x10$ X10_NPLACES=4 runx10 MyHello

各プレースで非同期に実行される

X10プログラムはJava（またはC++）に変換され，コンパイルされ

る

各プレースにアクティビティを生成し，並列分散実行


型安全で近代的なオブジェクト指向言語– マルチコアSMPチップやGPGPUなどが相互接続されたヘテロな並列分散環境に

対するスケーラブルなプログラミングを可能とする

基本的にはJava風

– オブジェクト指向，静的な型付け– 単一継承（インタフェースは複数可）– 実行開始はmain(Array[String])から– Javaに近い制御構文

• for，while，if，switch，…Javaとの違い

– 変数宣言などはScalaに近い• val，var，def, [T], ...

– より広範な総称型サポート– 符号なし整数型のサポート– 構造体や関数などの新しいデータ型– 強力な型推論，制約付きの型– そして，並列・分散処理の機能– ・・・

X10プログラムの概容

import x10.util.Pair; // struct to represent a pairpublic class MySample[T] {

val data:T;def this(d:T) { data = d; } // constructordef 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[UInt,UInt](3u,4u); // structval func = (i:UInt,j:UInt)=>i*j; // functionConsole.OUT.println(func(pair.first,pair.second)); // -> 12

}}

（私見では） X10≒Javaの制御構文＋Scala風の宣言と関数＋構造体＋独自の型システム・配列・スレッド・同期・分散処理機能

実行結果Sum of 1-10: 551.212


X10の開発状況

X10プロジェクトは2004年に開始

– ペタスケールマシン用の並列・分散プログラムをどうやって開発するか？

– 生産性の向上，ヘテロな環境への対応

ほぼ6～12週間ごとに新リリースを公開

– 現時点の最新版は2.2.1（9/29公開）この資料はこの版に基づく

– 引き続くリリースは，2.2.2（2011/12予定），2.3（2012/1H予定）

• 基本的には前方互換（古いソースは新しい処理系でもコンパイル可）

X10 Roadmap: http://x10-lang.org/home/codebase-progress.htmlRelease List: http://x10-lang.org/software/download-x10/release-list.html

2010

2011

0 11 12 1 2 3 4 5 6 7 8 9 10 11 12 1 2 3 4 5

.725

2.0.11/14

2.0.23/9

2.0.34/16

2.0.46/14

2.0.57/23

2.0.69/3

2.1.010/19

2.1.11/10

2.1.22/25

2.2.06/4

・・・

6 7 8 9 10

2.2.19/29

2.2.212/??

2.0.011/6


X10の開発体制X10はオープンソースプロジェクト

– プロジェクトページ：http://x10-lang.org/• 言語仕様のほか，チュートリアルやプログラム例など多数掲載

– ライセンスはEclipse Public License

ソースコード管理– SourceForge (svn) https://x10.svn.sourceforge.net/svnroot/x10/– JIRA (bug tracking) http://jira.codehaus.org/browse/XTENLANG

X10のコミュニティ– メーリングリスト http://sourceforge.net/mail/?group_id=181722

• ユーザー向け <[email protected]>• 開発者向け <[email protected]>

– X10 Innovation Awards (18 awards in 2010)– X10 Day on 2010/04/16– X10 BOF in SPLASH 2010 (2010/10)– X10 Workshop co-located with PLDI 2011 (2011/06)– X10 BOF in SPLASH 2011 (2011/10)– X10 Full Day Tutorial at Supercomputing ’11 (2011/11)– X10 Workshop co-located with PLDI 2011 (2011/06)– ...

EPL: http://www.eclipse.org/legal/epl-v10.html


X10プロジェクトページ：http://x10-lang.org/


Parsing /Type Check

AST OptimizationsAST Lowering

C++ CodeGeneration

Java CodeGeneration

C++ Source Java Source

C++ Compiler Java Compiler

Native Code Bytecode

X10 Compiler Front-End

C++ Back-End

Java Back-End

Java VMsNative EnvJNI

Native X10 Managed X10

X10の実装

X10コンパイラはJavaで実装されている

X10プログラムは，C++またはJavaのソースコードとしてコンパイルされる

X10RT：IBM PGAS runtime (binary only) or MPI-based (open source)

Java 5以上のJVMで動作

X10Source

AST: Abstract Syntax TreeXRX: X10 Runtime in X10XRJ: X10 Runtime in JavaXRC: X10 Runtime in C++X10RT: X10 Comm. Runtime

C++ back-end (x10c++)•C++ソースコードを生成

•各プロセス＝プレース

Java back-end (x10c)•Javaソースコードを生成•各JVM＝プレース

Common front-end•AST生成・型チェック

•最適化

X10 AST

XRX

X10RT

X10 AST

XRC XRJ

Linux, AIX, MacOS, Windows (Cygwin), GPGPU (CUDA),BlueGeneなどで動作


X10の開発環境：X10DTEclipseベースの統合開発環境

PTP

X10DT


X10DT: Integrated Development Tool for X10 ProgrammersA modern development environment for productive parallel programming

Building

Debugging

Editing

Help

Source navigation, syntax highlighting, parsing

errors, folding, hyperlinking, outline &

quick outline, hover help, content assist, type

hierarchy, format, search, call graph, quick fixes

Local and remote launch

Java/C++ back-end supportRemote target configuration

X10 programmer guide

X10DT usage guide

Integrated parallel X10

debugging Launching

from SC2011 X10 Tutorial


2. X10 2.2.1 言語仕様


解説記事（X10 2.1.2ベース）情報処理, Vol. 52, No. 3, pp. 342-356 (2011/03)


型安全で近代的なオブジェクト指向言語– マルチコアSMPチップやGPGPUなどが相互接続されたヘテロな並列分散環境に

対するスケーラブルなプログラミングを可能とする

基本的にはJava風

– オブジェクト指向，静的な型付け– 単一継承（インタフェースは複数可）– 実行開始はmain(Array[String])から– Javaに近い制御構文

• for，while，if，switch，…Javaとの違い

– 変数宣言などはScalaに近い• val，var，def, [T], ...

– より広範な総称型サポート– 符号なし整数型のサポート– 構造体や関数などの新しいデータ型– 強力な型推論，制約付きの型– そして，並列・分散処理の機能– ・・・

X10プログラムの概容（再掲）

import x10.util.Pair; // struct to represent a pairpublic class MySample[T] {

val data:T;def this(d:T) { data = d; } // constructordef 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[UInt,UInt](3u,4u); // structval func = (i:UInt,j:UInt)=>i*j; // functionConsole.OUT.println(func(pair.first,pair.second)); // -> 12

}}


X10の予約語と演算子

Javaとかなり重なっているが，並列・分散実行のためのキーワード等が追加されている

– X10では，プリミティブ型名（Int, Doubleなど）は予約語ではない

asasyncatateach(athome)atomicclockeddeffinishhaszeroherein

protectedpublicreturnstaticsuperswitchthisthrowtransienttruetryvoidwhile

booleanbytechar(const)doubleenumfloatintlongshortstrictfpsynchronizedthrowsvolatile

*括弧付きは未使用

Java 6の予約語

offeroffersoperatorpropertyselfstructtypevalvarwhen

abstractassertbreakcasecatchclasscontinuedefaultdoelseextendsfalsefinal

finallyfor(goto)ifimplementsimportinstanceofinterfacenativenewnullpackageprivate

X10 2.2.1の予約語 X10の演算子と優先順位


リテラル

X10のリテラルはJavaとほぼ同じ，主な違いは，

– 符号なし整数型用のリテラルがある

– X10独自の型のリテラル表現

true, false Boolean型のリテラル

null null値，オブジェクト型の変数に代入可能

123, -321, 0123（8進数), 0xBED(16進数) Int型のリテラル

1234567890l, 0x123456789ABCL Long型のリテラル

123u, 0123u, 0xBEAU UInt型のリテラル

123ul, 0124567012ul, 0xDecafC0ffeefUL ULong型のリテラル

414S, 0xACEs, 107us, 0xBeaus Short/UShort型のリテラル

50y, 0xBABY, 9uy, 0xBUY Byte/UByte型のリテラル

1f, 6.023E+32f, 6.626068E-34F Float型のリテラル

0.0, 0e100, 229792458d, 314159265e-8 Double型のリテラル

'c', '¥n', '¥t', '¥¥', '¥"', '¥101' Char型のリテラル

"hi! ", "" , "Hello¥n" String型のリテラル

(i:Int, j:Int):Int=>i*j 関数リテラル

[1, 3, 7] Array[Int]型のリテラル，Point型にも変換可

1..10 IntRange型のリテラル，Region型にも変換可

1..10 -> here Dist型の値を作る


演算子のユーザ定義

+などのオペレータもユーザ定義できる

defの代わりにoperatorで宣言

– 定義したいオペレータが来る所にそれを書けばよい

staticなオペレータも定義可能

（暗黙の）型変換も定義可能

– これを使えば，operator (n:Int)+this 等を

いちいち定義しなくて済む

public class MyPoly(a:Int,b:Int,c:Int) {// denotes a*x^2 + b*x + cpublic 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 + 0val t = -X + 3; // -X+3val u = 2*X + 1; // 2X+1val v = t * u; // (-X+3)(2X+1)Console.OUT.println(v); // -> -2*x^2 + 5*x + 3Console.OUT.println(v(2)); // -> 5val func = (p:MyPoly,q:MyPoly)=>p+q;Console.OUT.println(func(t,u)); // -> 0*x^2 + 1*x + 4

}}


X10のデータ型

X10は静的に型付けされた言語で，3つのデータ型を持つ

– オブジェクト（class），構造体（struct），関数（function）

オブジェクト（class） – Javaのオブジェクトとほぼ同じ

– クラスからnewにより生成される，参照経由でアクセスされる

– 生成されたプレースから移動できない（移動すると暗黙のうちにコピーされる）

構造体（struct） – メタ情報を持たないオブジェクト

– struct型から生成される，インライン可能

– 値は変更できない（immutable），プレース間で自由にコピー可能

– 参照渡しはできない，代入などの操作では値がコピーされる

– 構造体は「長いビット数のスカラー値」だと考えればよい

• IntやDoubleなどのプリミティブ型も，構造体として定義されている

関数（function） – 他の言語のクロージャやラムダ式に相当

– 一級データなので，変数に代入したり，引数として受け渡しも可能

– 値は変更できない（immutable），プレース間で自由にコピー可能


クラス（オブジェクト）とインタフェースの階層構造については，Javaと同様

型の階層構造クラスは階層構造をとる．単一継承，全てObjectのサブクラス

全ての型は，interface x10.lang.Anyのサブタイプ

クラスや構造体は複数のインタフェースや関数を実装できる

class x10.lang.Object class x10.array.Array[T]

class x10.util.HashMap[K,V]

class ～ class ～

class ～

interface x10.util.Map[K,V] interface ～

interface ～

interface x10.lang.Any

(Int, Int)=>Int

struct x10.lang.Int

struct ～

(Double)=>Double

A B B extends AX Y Y implements X


構造体と関数構造体 ≒ ユーザー定義可能なプリミティブ型

「長いビット数のスカラー値」と考えればよい*– IntやDoubleなどのプリミティブ型も，構造

体として定義されている（実装はネイティブ）

– 参照はとれない，常に値渡し

– 「==」は内容が同じかどうかで判定

継承（extends）はできないが，インタフェースや関数の実装（implements）は可能

型パラメータも使用可能

構造体の値を作るには，new無しでコンストラクタを呼ぶ

関数（クロージャ）を一級データとして扱える

変数に代入したり，引数として受け渡しできる

関数の型やリテラルは「=>」を使って記述

– functionのようなキーワードはない

関数は( )を使って呼び出せる

関数は「実装（implements）」可能

– 呼び出すと，引数の型に対応するthis(～)演算子が実行される

public struct MyPair[T,U] implements (String)=>String {val first:T, second:U; def this(f:T,s:U) { first=f; second=s; }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)); // -> 20var a:Any = p;Console.OUT.println(a.typeName());

// -> MyPair[x10.lang.Int,x10.lang.Double]/* Function example */val power = (f:Double,g:Double)=>Math.pow(f,g);Console.OUT.println(power(2,5)); // -> 32.0val square = curry[Double](power, 2);Console.OUT.println(square(5)); // -> 25.0val 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

} }

* ただし，Java back-endでは現在，ユーザー定義のstructはJavaのクラスとして実装されている


型推論と制約付きの型X10コンパイラは，変数や返り値の型を推論（infer）する

推測できる場合は型の指定を省略可能特に，valによる変数宣言では，省略する方が推奨される（X10コンパイラが適切な型を制約つきで推論する）

X10では，型やメソッドに「制約（constraints）」をつけられるTypeName{式}で指定する（使える式にはかなり制限あり）

– 例：String{self != null}は，nullでないStringを表す型

– 例：42の最も厳密な型は，Int{self==42}

配列の次元（rank）を制限する時などに便利

制約は基本的に，コンパイル時に型推論によりチェックされる

– 静的に判定できないものは，実行時に動的チェックされる（コンパイル時に警告が出る）

– コンパイルエラーにしたい場合，「x10c –STATIC_CALLS ～」でコンパイルする

public class MyConstraint {static def addPoints(p:Point, q:Point{rank==p.rank}):Point{rank==p.rank} {

return Point.make(p.rank, (i:Int)=>p(i)+q(i)); // returns a new Point}

public static def main(args:Array[String]) {val p0 = [1,2,3] as Point; // inferred type is Point{rank==3}val p1 = [4,5,6] as Point; // inferred type is Point{rank==3}val p2 = addPoints(p0, p1); // OK, result is Point{rank==3}Console.OUT.println(p2); // -> [5,7,9] val p3 = [7,8] as Point; // inferred type is Point{rank==2}

//val p4 = addPoints(p2, p3); // compile error!val p5:Point = [9,10]; // type is Point (without constraints)

//val p6 = addPoints(p2, p5); // runtime error (FailedDynamicCheckException)}

}


配列X10には，言語コンストラクトとしての配列

は存在しない「this(～)=～」および「this(～)」という演算子により，配列アクセス風の処理を一般化した形で実現配列アクセスは「[ ]」でなく「( )」で行う

– 内部的には上記の演算子が呼ばれる

配列処理のための標準クラスPoint はn次元整数格子上の1点を表す

– n次元配列の「添え字」として使用可Region は次元（rank）が同じPointの集合を表す

– 配列の「有効な添え字（定義域）」を示すのに使用できる

Array[T] は要素の型がTの配列を表す– 定義域はRegion（など）で指定される

– 多次元配列や添え字が負の配列，要素が疎な配列，三角行列なども柔軟に表現できる

public class MyAssoc[T] { // simple associative arrayval 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")=1aa("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==3Console.OUT.println(pt1(1)); // -> 3val [a,b,c] = pt1; // a==1, b==3, c==7val pt2[x,y] = Point.make(1,3); // x==1, y==3Console.OUT.println(pt2); // -> [1,3]/* Region */val R1 = 3..5; // rank==1val R2 = (-1..1)*R1; // rank==2Console.OUT.println(R2.contains(pt2)); // -> true/* Array */val arr1 = new Array[Int](R2, ([i,j]:Point)=>i*j);Console.OUT.println(arr1(pt2)); // -> 3Console.OUT.println(arr1(-1,4)); // -> -4

} }


ポイント, リージョン, そして配列へx10.array.Pointはn次元上の1点を表す．n次元配列の「添え字」として使用できる

– 例：val pt = [1,3,7] as Point; 3次元上のPoint [1,3,7]• pt(1)などで対応する要素を取り出せる（上の例だと3）

– Pointの要素はIntに固定で変更不能，次元はrankプロパティでわかる– Pointのdestructuring access

• val [i,j,k] = [1,3,7] as Point; i=1, j=3, k=7• val p[i,j] = Point.make(2,3); p=[2,3], i=2, j=3• for ([i] in 1..10) ～も実はこれの一種

x10.array.Regionは次元（rank）が同じPointの集合．配列の「有効な添え字」を表す– 例：val R1 = 1..5; 1次元のPoint [1][2][3][4][5]からなるRegion{rank==1}– 例：val R2 = (1..2)*(3..5);

2次元のPoint [1,3][1,4][1,5][2,3][2,4][2,5]からなるRegion{rank==2}– 注：Regionに実際にPointが入っているわけではなく，集合の「形」を覚えている– Region同士の演算もいろいろ定義されている（省略）

x10.array.Array[T]はローカルな配列．指定されたRegionが定義域，各要素はT型– 例：val arr = new Array[Int](1..5); arr(3) = ...– X10の配列はゼロから始まらなくてもよいし，要素に「すき間」があってもよい


複数のプレースで複数のアクティビティを実行することで，並列・分散処理

X10の特徴的な構文・データ構造

X10による並列・分散処理（再掲）

細粒度並列処理• async S

排他制御• atomic S• when (cond) S

実行の同期• finish S• clocked

分散データ構造• Point, Region, Dist• DistArray

分散処理• at (place) S

分散配列

分散配列


async at at at



オブジェクト

アドレス空間

ローカル参照


リモート参照

生成

移動


プレースプレースはプロセッサ（もしくは1台のマシン）に対応すると考えればよい

プレースの構成と数（Place.MAX_PLACES）は実行中には変化しない

プレースには，0からの続き番号（id）が振られている

x10.lang.Placeはビルトインの構造体，プロパティ「id」に番号が入る

hereは「現在のプレース」を示す

– here.next()は「隣のプレース」を示す（idは一周する）

async文で，同じプレース内に新しいアクティビティを生成できる

at文で他のプレースに移動できる

変更可能（mutable）なデータは特定のプレースに所属しており，同じプレースのアクティビティからしかアクセスできない（参照は可能）

構造体や関数，クラスは変更不能（immutable）なデータであり，どのプレースからも自由にアクセスできる

オブジェクトは特定のプレースに所属しており，生成されたプレースからしかアクセスできない

– atブロック内からオブジェクトにアクセスすると，暗黙のうちに複製が作られるため，取り扱いには注意が必要

package x10.lang;public final struct Place(id:Int) {

public static MAX_PLACES:Int;public static places:Array[Place](1)

= new Array[Place](MAX_PLACES, ((id:Int) => Place(id)));public const FIRST_PLACE:Place(0) = Place(0);public def this(id:Int):Place(id) { property(id); }public static def place(id: Int):Place(id) = Place(id);public def next():Place = next(1);

:}

* X10 2.1では変更の可能性あり


並列・分散処理並列処理

async S は，同じプレースに子アクティビティを生成し，Sを実行

– asyncを実行した親アクティビティは，すぐに次の文の実行へ進む

– S内から外側のローカル変数にアクセス可finish S は，S内で生成された全てのアクティビティ（孫も含む）が終了するまで待つ

– S内で起こった例外をトラップしてthrow

分散処理at (pl) S は，アクティビティがplで指定されたプレースに移動して，Sを実行する

– Sが終了すると次の文へ進む（asyncで生成したアクティビティは終了していなくてもよい）

– S内から外側のval変数にアクセス可atブロック内からオブジェクトにアクセスすると，暗黙のうちに複製が作られるので注意

– オブジェクトをGlobalRef[T]という構造体に入れることで，同一オブジェクトへのグローバルな参照を持つことができる（アクセスするには，元のプレースに移動）

public class MyFib {var r:Int; // in-out parameterdef this(i:Int) { r = i; }def run() {

if (r < 2) return r; // MyFib(0)==0, MyFib(1)==1val f1 = new MyFib(r-1), f2 = new MyFib(r-2);finish {

async f1.run(); // compute MyFib(r-1) in parallelf2.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/* Object and GlobalRef */val o = new MyFib(0);at (here.next()) o.r = 1; // copy of o is modifiedConsole.OUT.println(o.r); // -> 0val g = GlobalRef[MyFib](o);at (here.next()) { at (g.home) g().r = 2; }Console.OUT.println(o.r); // -> 2

} }


排他制御同一プレース内のアクティビティ間は

排他制御が可能注：X10では，異なるプレース間の排他制御はできない（そもそも書き込めるデータはプレース間で共有できない）注：Javaのような，オブジェクトを指定した排他制御はできない

排他処理atomic S は，Sがプレース内で不可分に実行されることを指定

– メソッドをatomicと宣言することも可能– 他に，AtomicIntegerなどのクラスも

使用可能条件待ち

when (cond) S は，指定された条件が成立するまでブロックする

– condが成立したらSが不可分（atomic）に実行される

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); // sendersfor ([i] in 0..9) Console.OUT.print(buf.receive());Console.OUT.println(); // -> 0217635489 (etc.)

}

（次ページに続く）


同期制御

バリア同期

同一プレース内のアクティビティ間で複数回のバリア同期が可能

clocked finish により，「クロック」を生成

clocked async により，生成したアクティビティをクロックに「登録」

各アクティビティは，1フェーズ分の処理を終えるとadvanceAll()を実行

– クロックに登録されている全アクティビティがadvanceAll()を呼ぶまで，処理がブロックされる

複雑な同期のためには，Clockオブジェクトを明示的に生成したり，複数使用することも可能

（前ページから続く）

/* Clocked execution */clocked finish {

clocked async { // clocked activity Asay("A-1 "); Clock.advanceAll();say(" A-2"); Clock.advanceAll();say("A-3 ");

}clocked async { // clocked activity B

System.sleep(1000); // sleep 1 secsay("B-1 "); Clock.advanceAll();say(" B-2"); Clock.advanceAll();say("B-3 ");

}clocked async { // clocked activity C

for ([i] in 1..3) {val spc = (i%2==0) ? " " : "";say(spc + "C-" + i); Clock.advanceAll();

} } }} }

実行例A-1 C-1B-1

C-2B-2A-2

B-3 C-3A-3


デッドロックの抑止

以下の条件を満たすX10プログラムはデッドロックしない（できない）

1. at, async, finish, atomicは自由に使ってよい

– ちなみに，X10のasyncが「ハンドル」を返さないのは，

デッドロックするプログラムを本質的に書けなくするため

2. whenは使わない

3. クロックは使ってよいが，finishブロックの外側で生成したクロックを内側で使わない

– clocked finishとclocked asyncを

セットで使用し，途中に余計なfinishをはさまなければ問題は

生じない

不適切なクロック使用でデッドロックする例val c = Clock.make();async clocked(c) { // clocked activity A

finish async clocked(c) { // clocked activity B <==Clock.advanceAll(); // B-next, blocks until A-next

}Clock.advanceAll(); // A-next, never executed

}


分散配列X10では，要素が各プレースに

散らばった「分散配列」を作成可能

Dist はRegion内の各PointからPlaceへの写像

– 分散配列の各要素がどのプレースに存在するかを表す

– 「D | place」や「D | region」で，要素を制限できる

DistArray[T] は要素が各プレースに分散して存在する配列

– 定義域と要素の存在場所は，作成時にDistで指定される

– newではなく，DistArray.makeメソッドで作る（今のところ）

– 要素にアクセスするには，そのプレースに移動する必要がある

– Distと同様に「|」で要素の制限が可能

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)->3Console.OUT.println(D1(3)); // -> (Place 1)val D2 = D1 | here; // (0)->0 (1)->0 (2)->0val D3 = D1 | 2..4; // (2)->0 (3)->1 (4)->1val D4 = 0..9->here; // (0..9)->0val 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));

（次ページへ続く）

5 610 1215 1820 24

da =

i = 1234

j = 5 6

プレース0に存在





分散配列の使用例

12 + 22 + ・・・ + 10002 の計算を

複数プレースで分担して行う

1～1000の値を分散配列da0に用意

各プレースでの計算結果を入れるローカル配列tmpを用意

各プレースで分散して以下の処理

– 自プレースにある要素vについて，v*vを求め，合計する

各プレースでの計算が終わったら，tmpの要素を合計し，結果を出力

実は，DistArrayに同様の処理を行う

便利メソッドが用意されている

– map(func:(T)=>T):DistArray[T]– reduce(func:(T,T)=>T, unit:T):T

（前ページから続く）

/* 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; // restrictionvar 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((i:Int,j:Int)=>i+j, 0);Console.OUT.println(s1); // -> 333833500

}}


X10標準ライブラリ

Arrayに加え，Math, HashMapなど

の基本的な機能が用意されている

– http://dist.codehaus.org/x10/xdoc/で仕様を確認可能

• Javadoc形式なので少し見づらい，

ソースを見る方が早いかも・・・

用意されている主なクラス（またはstruct）– x10.lang.Any, Object, Int, String,

Place, Clock, GlobalRef[T], PlaceLocalHandle[T], System, Math, Complex, Cell[T],...

– x10.array.Point, Region, Dist, DistArray[T], Array[T], ...– x10.io.Console, File, Reader, Writer, Printer, ...– x10.util.HashMap[K,V], Timer, Random, Box[T], Pair[T,U], ...– x10.util.concurrent.atomic.AtomicInteger, AtomicReference[T], Fences, ...– x10.lang.*とx10.array.*は，自動的にimportされる


3. X10を試してみる


X10を試してみるには？X10DT（X10 Development Toolkit）を利用するのが最も簡単

– http://x10-lang.org/software/ide-a-editor-plugins.html– Eclipse（3.6.2 Helios）も含んだzipが用意されている

– Linux x86, Linux x86_64, MacOS x86, Win32+cygwin用がある

X10DTの解凍と起動例（注：起動にはJava環境が必要）

$ ls -l x10dt-2.2.1-win32.win32.x86.zip-rwx------+ 1 kawatiya 209927692 x10dt-2.2.1-win32.win32.x86.zip$ md5sum x10dt-2.2.1-win32.win32.x86.zip5c9b60c5fdf29477833e444b9ae021ab x10dt-2.2.1-win32.win32.x86.zip$ cd c:/$ unzip x10dt-2.2.1-win32.win32.x86.zip

creating: x10dt/:

inflating: x10dt/readme/readme_eclipse.html inflating: x10dt/x10dt.exe inflating: x10dt/x10dt.ini

$ cd x10dt$ ls./ artifacts.xml features/ plugins/ x10dt.ini../ configuration/ notice.html readme/.eclipseproduct epl-v10.html p2/ x10dt.exe$ ./x10dt.exe


Workspaceはとりあえずデフォルトで起動x10dt/workspace/が作成される

Workbenchへ移動

簡単なヘルプ


X10プロジェクト「x10test」を作るFile New X10 Project (Java back-end), x10test

src/Hello.x10が自動的に作られる選択してRun Runで実行可能

X10クラス「MyHeatTransfer」を作るFile New X10 Class, MyHeatTransfer

src/MyHeatTransfer.x10が作られる


MyHeatTransfer on X10DTコードを入力して，Runで実行

実行結果


Σ ÷ 4

A:1.0

n

n

from GroveX10 UT June 2010.pptMyHeatTransfer：温度伝播の計算

NxNの二次元領域に温度がどのように伝播するかを分散計算する

– 条件：１辺は常に温度1.0，他の３辺が温度0.0

– 以下の計算を繰り返す

最大の変化がε以下になるまで繰り返す


MyHeatTransfer：温度伝播の計算 modified from GroveX10 UT June 2010.ppt

public class MyHeatTransfer { // from "GroveX10 UT June 2010.ppt", modified by [email protected] val N=5, epsilon=0.01;static def dump(X:DistArray[Double](2)) { val last = X.region.max(1); // last index for j

for (p[i,j] in X) Console.OUT.printf("%3.2f%s", at (X.dist(p)) X(p), j!=last ? " " : "¥n");}static def stencil_1(A:DistArray[Double](2), [x,y]:Point(2)) { // heat transfer for a point

return ( (at(A.dist(x-1,y)) A(x-1,y)) + (at(A.dist(x+1,y)) A(x+1,y)) + A(x,y-1) + A(x,y+1) ) / 4;}public static def main(Array[String]) { Console.OUT.println("N=" + N);

val BigD = Dist.makeBlock((0..(N+1))*(0..(N+1)), 0); // Dist for the bigger region including the borderval D = BigD | ((1..N)*(1..N)); // Dist for the NxN region, which is part of BigDval A = DistArray.make[Double](BigD, ([i,j]:Point)=>(i==0 ? 1.0 : 0.0)); // main DistArrayval Temp = DistArray.make[Double](BigD), Scratch = DistArray.make[Double](BigD);

val D_Base = Dist.makeUnique(D.places());var delta:Double;do { dump(A); // to check intermediate states

finish ateach (z in D_Base) // at each place of D, do parallelfor (p:Point(2) in D|here) Temp(p) = stencil_1(A, p);

delta = A.map(Scratch, Temp, D.region, (x:Double,y:Double)=>Math.abs(x-y)).reduce((x:Double,y:Double)=>Math.max(x,y), 0.0); // get max delta

Console.OUT.printf("---- delta=%4.3f ----¥n", delta);finish ateach (p in D) A(p) = Temp(p); // copy the array in parallel

} while (delta >= epsilon); dump(A); // dump the final result} }

ResultN=5---- delta=0.010 ----1.00 1.00 1.00 1.00 1.00 1.00 1.000.00 0.45 0.60 0.64 0.60 0.45 0.000.00 0.22 0.33 0.37 0.33 0.22 0.000.00 0.10 0.17 0.19 0.17 0.10 0.000.00 0.05 0.08 0.09 0.08 0.05 0.000.00 0.02 0.03 0.03 0.03 0.02 0.000.00 0.00 0.00 0.00 0.00 0.00 0.00

Σ ÷ 4


MyHeatTransfer：分散実行の結果（C++ back-end）

C++ back-endを用い，4プレースで分散実行した例


4. ソフトウェア開発の実際


X10の開発体制（再掲）X10はオープンソースプロジェクト









SVN (Subversion)によるソースコード管理


JIRA: Bug Report and Tracking


Parsing /Type Check

AST OptimizationsAST Lowering

C++ CodeGeneration

Java CodeGeneration

C++ Source Java Source

C++ Compiler Java Compiler XRJ

Native Code Bytecode

X10 Compiler Front-End

C++ Back-End

Java Back-End

Java VMsNative EnvJNI

Native X10 Managed X10

X10の実装（再掲）

X10コンパイラはJavaで実装されている

X10プログラムは，C++またはJavaのソースコードとしてコンパイルされる

X10Source

AST: Abstract Syntax TreeXRX: X10 Runtime in X10XRJ: X10 Runtime in JavaXRC: X10 Runtime in C++X10RT: X10 Comm. Runtime

TRL

X10 AST

XRX

X10RT

X10 AST

XRC


Challenges in Compiling X10 to JavaTypes – mapping of X10 data types to Java

– How to translate X10 types (incl. structs and functions) to Java?– How to utilize Java primitive types?

Generics – gaps between X10 generics and Java generics– How to implement X10’s richer generics semantics?

Arrays – optimizations of array access– How to make X10 Array performance comparable to Java?

Places – distributed execution– How to utilize multiple computer nodes to run an X10 application?

and others ...竹内ほか「Compiling X10 to Java」より


X10 TypesX10 has richer types than Java, and they need to be mapped to Java

interface x10.lang.Any

(Int, Int)=>Int

struct x10.lang.Int

struct MyStruct

(Double)=>Double

class x10.lang.Object class x10.lang.String

class x10.array.Array[T]

class MyClass class MySubClass

class ～

interface x10.util.Map[K,V] interface ～

interface MyInterface

A B B extends AX Y Y implements X

interface MySubInterface

Interface “Any” as a top-levelStructs and functionsInt (and UInt, ...) are structsNo “int” or built-in arrayX10

struct x10.lang.UInt

class x10.util.HashMap[K,V]

class x10.lang.Throwable class MyThrowable

竹内ほか「Compiling X10 to Java」より


class java.lang.Object

class java.lang.Integer

class java.lang.RuntimeException class x10.core.Throwable

interface x10.core.fun.Fun

interface x10.core.Any

interface x10.core.RefI

class MyThrowable

interface x10.core.fun.Fun_0_0<U>

interface x10.core.fun.Fun_0_1<T1,U>

abstract class x10.core.Struct

class x10.array.Array<T>

class x10.core.Ref class x10.core.String

class MyClass class MySubClass

class MyStruct

class x10.lang.UInt

static classMyClass$$Closure$0

interface MyInterface interface MySubInterface

A B B extends AX Y Y implements XA B B extends AX Y Y implements X

interface x10.core.StructI

class java.lang.String

Mapping X10 Types to Java

Interfaces to represent class/struct/functionSome X10 types are mapped to Java primitives or well-known Java classesThrowables are under RuntimeException

Java

int

(in X10 2.2.0)

Unsigned types will be mapped to Java primitives in X10 2.2.1

竹内ほか「Compiling X10 to Java」より


Compiling X10 to Java1 class C(p:Int) {2 val q:Int; var r:Int;3 def u() { }4 private def v() { }5 def w() { return super.hashCode(); }6 def this(p:Int) {7 property(p);8 q = 1;9 }

10 static val s = Place.MAX_PLACES;11 static def t() { } 12 }

1 import x10.lang.Place;2 import x10.lang.Runtime;3 import x10.runtime.impl.java.InitDispatcher;4 public class C extends x10.core.Ref {5 public int p; // property6 public int q, r; // instance fields7 final public int p() { return this.p; } // property method8 public void u() { } // instance methods9 private void v() { }

10 // bridge method for private instance method11 public static void v$P(final C C) { C.v(); }12 public int w() { return super.hashCode(); }13 // bridge method for super.hashCode()14 final public int C$hashCode$S() { return super.hashCode(); }15 public C(final int p) { // constructor16 super();17 this.p = p;18 this.__fieldInitializers173();19 this.q = 1;20 }21 // instance field initializer22 final private void __fieldInitializers173() { this.r = 0; }23 // bridge method for field initializer24 final public static void __fieldInitializers173$P(final C C) {25 C.__fieldInitializers173();26 }27 public static int s = 0; // static field28 public static void t() { } // static method29 // static initialization30 public static int fieldId$s; // static field id31 // static field initializer32 public static int getInitialized$s() {33 if (Runtime.hereInt() == 0) {34 C.s = Place.getInitialized$MAX_PLACES();35 InitDispatcher.broadcastStaticField(C.s, C.fieldId$s);36 }37 return C.s;38 }39 // static field deserializer40 public static void getDeserialized$s(byte[] buf) {41 C.s = (Integer) InitDispatcher.deserializeField(buf);42 }43 static { // Java static initializer44 C.fieldId$s = InitDispatcher.addInitializer("C", "s");45 }46 }

X10

Java

x10c

(som

e lin

es a

re o

mitt

ed)

Class/field names are basically same

Constructor is separated into Java constructor and field initializer

For private instance method, additional bridge method is generated

Static-field initializer and deserializerare generated

– to support inlining by front-end

– to support multi-place initialization竹内ほか「Compiling X10 to Java」より


X10の開発体制（再々掲）X10はオープンソースプロジェクト









X10 Community DevelopmentX10 Application Development• Dynamic Graph Data Structures in X10, David Bader, Georgia Tech • X10 Media Composer (XMC), Admela Jukan, University of Braunschweig, Germany • Leveraging X10 for Open-Source, Platform-Level, Cloud Computing, Chandra Krintz, UC Santa Barbara • Systematic Testing in and for X10, Darko Marinov, UIUC • Fine-grained Concurrent Compilation with X10, Nathaniel Nystrom, UT Arlington • Using X10-enabled MapReduce Framework for Intercomparison of Satellite Aerosol Data Analysis, Yelena Yesha, U. Maryland • MapReduce framework on heterogeneous cluster, Yu Wang, Tsinghua University, China • Dynamic programming algorithms in X10, Guangwen Yang, Tsinghua University, China • Financial Risk Computing using X10, Hui Liu, Shandong University, China • Stream programming on X10, Junqing Yu, Huazhong University of Science and Technology, China • Exploiting concurrency in large-scale botnet detection, Shishir Nagaraja, Indraprastha Institute of Technology, India X10 Tool Development• Prototyping a Novel Performance Toolset for X10 Applications, Alan George, University of Florida • Optimization and Verification of X10 Programs, Jens Palsberg, UCLA • Lightweight deterministic replay of X10 programs, Charles Zhang, The Hong Kong University of Science and Technology, China • Checking serializability consistency for concurrent X10 programs, Jianjun Zhao, Shanghai Jiao Tong University, China Framework/Libraries• Transactions for Reliable Distributed X10 Execution, Anthony Hosking, Purdue University • Automatic Adaptation of Java Frameworks for X10 to Improve Programmer Productivity, Eli Tilevich, Virginia Tech • High performance clustering algorithms libraries in X10, Xiaoyun Chen, Lanzhou University, China Mapping High-Level Languages to X10• Embracing the Parallelism of Forward Linear Logic Programming, Frank Pfenning, CMU • Scripting on X10 - Ruby Script to X10 Program Translator, Koichi Sasada, University of Tokyo, Japan Language Research• Concurrency Types for X10: Race-Freedom, Atomicity, and Determinism, Cormac Flanagan, UCSC • Improving performance of the X10 runtime for multi-core, Haibo Chen, Fudan University, China Curricula Development• A First Programming Course using X10, Robert (Corky) Cartwright/Vivek Sarkar, Rice University • Teaching Real-World Parallel and Distributed Programming, Steven Reiss, Brown University • Migrating Undergraduate Parallel Computing Courses to X10, Claudia Fohry, University of Kassel, Germany • X10 Tutorial and Workshop Development, Steven Gordon/Dave Hudak, Ohio Supercomputing Center • Teaching Parallel Programming as a Pattern Language on the Example of X10, Christoph von Praun, Georg-Simon-Ohm University, Germany • Astronomical research and parallel computing course, Ce Yu, Tianjin University, China • Parallel computing and programming in X10 (graduate),Shaohua Liu, Beijing University of Posts and Telecommunications, China • Courseware for an advanced undergraduates CS course, Xiaoge Wang, Tsinghua University, China

http://x10-lang.org/


Community Outreach in JapanX10 Seminar in JSSST PPL Summer School (2010/09)X10 Explanation Article in “IPSJ Magazine” (2011/03)An article in “IBM ProVISION” (2011/05)A paper in X10 workshop 2011,

co-located with PLDI 2011 (2011/06)


X10 Publications2011

Neptune: A Domain Specific Language for Deploying HPC Software on Cloud Platforms. Chris Bunch, NavrajChohan, Chandra Krintz, and Khawaja Shams. ScienceCloud’11, June 2011.Resource-aware programming and simulation of MPSoC architectures through extension of X10. Frank Hannig, Sascha Roloff, Gregor Snelting, Jürgen Teich, and Andreas Zwinkau. The 14th International Workshop on Software and Compilers for Embedded Systems, June 2011A Performance Model for X10 Applications. David Grove, Olivier Tardieu, David Cunningham, Ben Herta, Igor Peshansky and Vijay Saraswat. ACM SIGPLAN 2011 X10 Workshop, June 2011.Parallel Programming: Design of an Overview Class. by Christoph von Praun. ACM SIGPLAN 2011 X10 Wokrshop, June 2011.Compiling X10 to Java. by Mikio Takeuchi, Yuki Makino, Kiyokuni Kawachiya, Hiroshi Horii, Toyotaro Suzumura, Toshio Suganuma, and Tamiya Onodera. ACM SIGPLAN 2011 X10 Workshop, June 2011.Work-Stealing by Stealing States from Live Stack Frames of a Running Application. by Vivek Kumar, Daniel Frampton, David Grove, Olivier Tardieu, and Steve Blackburn. ACM SIGPLAN 2011 X10 Workshop, June 2011.Using the Cowichan Problems to Investigate the Programmability of X10 Programming System. by Jeeva Paudel and Jose Nelson Amaral. ACM SIGPLAN 2011 X10 Workshop, June 2011.X10 implementation of Parallel Option Pricing with BSDE method. by Hui LIU, Ying Peng, DaiZhen Wei and Bin Dai. ACM SIGPLAN 2011 X10 Workshop, June 2011.Distributed deductive databases, declaratively: The L10 logic programming language. by Robert Simmons, Frank Pfenning, and Bernardo Toninho. ACM SIGPLAN 2011 X10 Workshop, June 2011.GPU Programming in a High Level Language Compiling X10 to CUDA. by David Cunningham, Rajesh Bordawekar, and Vijay Saraswat. ACM SIGPLAN 2011 X10 Workshop, June 2011.X10 as a Parallel Language for Scientific Computation: Practice and Experience. Josh Milthorpe, V. Ganesh, Alistair P. Rendell and David Grove. IEEE International Parallel and Distributed Processing Symposium, May 2011.Open Language Implementation. Mandana Vaziri, Robert Fuhrer, Evelyn Duesterwald. IWMSE '11, 4th international workshop on Multicore Software Engineering, May 2011.Communication Optimizations for Distirbuted-Memory X10 Programs. Rajkishore Barik, Jisheng Zhao, David Grove, Igor Peshansky, Zoran Budimlic, and Vivek Sarkar. IEEE International Parallel and Distributed Processing Symposium, May 2011.Lifeline-based Global Load Balancing. Vijay A. Saraswat, Prabhanjan Kambadur, Sreedhar Kodali, David Grove, Sriram Krishnamoorthy, PPOPP'11, Feb 2011Design and Implementation of a DSL based on Ruby for Parallel Programming. Tetsu Soh. Master Thesis, Graduate School of Information Science and Technology, The University of Tokyo, January 2011.

2010Featherweight X10: a core calculus for async-finish parallelism. Jonathan K. Lee and Jens Palsberg, 15th ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming, January, 2010.Reducing task creation and termination overhead in explicitly parallel programs. J Zhao, J Shirako, V K Nandivada, V Sarkar, 19th international conference on Parallel architectures and compilation techniques, 2010.Inferring Arbitrary Distributions for Data and Computation. Soham S. Chakraborty, V K Nandivada, SPLASH Onward!, ACM, 2010.A Proof System for a PGAS Language. Shivali Agarwal1 and R.K. Shyamasundar. Concurrency, Compositionality and Correctness 2010.Fast PGAS Implementation of Distributed Graph Algorithms. Guojing Cong, George Almasi, Vijay Saraswat, SC'10, 2010 ACM/IEEE International Conference for High Performance Computing, Networking, Storage and Analysis, Nov 2010.The Asynchronous Partitioned Global Address Space Model. Vijay Saraswat George Almasi Ganesh Bikshandi CalinCascaval David Cunningham, AMP, Workshop on Advances in Message Passing, June 2010.Efficient Data Race Detection for Async-Finish Parallelism. Raghavan Raman, Jisheng Zhao, Vivek Sarkar, Martin Vechev, Eran Yahav. 1st International Conference on Runtime Verification (RV'10), November 2010.

2009Efficient Optimization of Memory Accesses in Parallel Programs. Rajkishore Barik. Ph.D. thesis,Department of Computer Science, Rice University, October 2009.Concurrency Refactoring for X10. Robert M. Fuhrer and Vijay Saraswat. ACM 3rd workshop on refactoring tools, WRT'09, Oct 2009Extracting Concurrency via Refactoring in X10. Shane Markstrum and Robert M. Fuhrer.ACM 3rd workshop on refactoring tools, WRT'09, Oct 2009Hierarchical Place Trees: A Portable Abstraction for Task Parallelism and Data Movement. Yonghong Yan, JishengZhao, Yi Guo, Vivek Sarkar. 22nd Workshop on Languages and Compilers for Parallel Computing (LCPC), October 2009.Fast PGAS Connected Components Algorithms . Guojing Cong, Gheorghe Almasi, Vijay Saraswat. PGAS conference, 2009.A Comparative Study and Empirical Evaluation of Global View HPL Program in X10. Ganesh Bikshandi, Gheorghe Almasi, Sreedhar Kodali, Vijay Saraswat, Sayantan Sur. PGAS conference, 2009

Interprocedural Load Elimination for Dynamic Optimization of Parallel Programs. Rajkishore Barik, Vivek Sarkar. The Eighteenth International Conference on Parallel Architectures and Compilation Techniques (PACT), September 2009.Chunking Parallel Loops in the Presence of Synchronization . Jun Shirako, Jisheng Zhao, V. Krishna Nandivada, Vivek Sarkar. ACM International Conference on Supercomputing (ICS), June 2009.Work-First and Help-First Scheduling Policies for Terminally Strict Parallel Programs. Yi Guo, Rajkishore Barik, Raghavan Raman, Vivek Sarkar. 23rd IEEE International Parallel and Distributed Processing Symposium (IPDPS), May 2009.Phaser Accumulators: a New Reduction Construct for Dynamic Parallelism. Jun Shirako, David Peixotto, VivekSarkar, William Scherer. 23rd IEEE International Parallel and Distributed Processing Symposium (IPDPS), May 2009.Compiler Support for Work-Stealing Parallel Runtime Systems. Raghavan Raman. M.S. thesis, Department of Computer Science, Rice University, May 2009.Compile-Time Analysis and Specialization of Clocks in Concurrent Programs. Nalini Vasudevan, Olivier Tardieu, Julian Dolby and Stephen A. Edwards, Compiler Construction 2009Efficient, portable implementation of asynchronous multi-place programs . Ganesh Bikshandi, José G. Castaños, Sreedhar B. Kodali, V. Krishna Nandivada, Igor Peshansky, Vijay A. Saraswat, Sayantan Sur, Pradeep Varma, Tong Wen: PPOPP 2009, Feb 2009.Idempotent Work Stealing. Maged Michael, Martin Vechev, Vijay Saraswat, PPOPP 2009, Feb 2009Towards concurrency refactoring for X10. Shane A. Markstrum, Robert M. Fuhrer, Todd D. Millstein, PPOPP, Feb, 2009Constrained Kinds. Nathaniel Nystrom, Olivier Tardieu, Igor Peshansky, Vijay Saraswat. Technical Report, 2009

2008Static Detection of Place Locality and Elimination of Runtime Checks . Shivali Agarwal, Rajkishore Barik, V. Krishna Nandivada, R. K. Shyamasundar, Pradeep Varma, APLAS 2008Constrained types for object-oriented languages. Nathaniel Nystrom, Vijay Saraswat, Jens Palsberg, Christian Grothoff, OOSPLA, October 2008.Array Optimizations for High Productivity Programming Languages. Mackale Joyner. Ph.D. thesis. Department of Computer Science, Rice University, September 2008.Phasers: a Unified Deadlock-Free Construct for Collective and Point-to-point Synchronization. Jun Shirako, David Peixotto, Vivek Sarkar, WIlliam Scherer, ACM International Conference on Supercomputing (ICS), June 2008.Array Optimizations for Parallel Implementations of High Productivity Languages, Mackale Joyner, Zoran Budimlic, Vivek Sarkar, Rui Zhang. HIPS-POHLL workshop, co-located with IPDPS. April 2008.Type Inference for Locality Analysis of Distributed Data Structures. Satish Chandra, Vijay Saraswat, Vivek Sarkar, Ras Bodik. ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP), February 2008.

2007Language Extensions in Support of Compiler Parallelization. Jun Shirako, Hironori Kasahara, Vivek Sarkar. Twentieth Workshop on Languages and Compilers for Parallel Computing (LCPC), October 2007.Optimizing Array Accesses in High Productivity Languages. Mackale Joyner, Zoran Budimlic, Vivek Sarkar. 2007 High Performance Computation Conference (HPCC), September 2007.Deadlock-Free Scheduling of X10 Computations with Bounded Resources. Shivali Agarwal, Rajkishore Barik, Dan Bonachea, Vivek Sarkar, Rudrapatna Shyamasundar, Katherine Yelick. 19th Annual ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’07), June 2007.May-Happen-in-Parallel Analysis of X10 programs. Shivali Agarwal, Rajkishore Barik, Vivek Sarkar, RudrapatnaShyamasundar. ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP), March 2007.

2006Experiences with an SMP Implementation for X10 based on the Java Concurrency Utilities. Rajkishore Barik, Vincent Cave, Christopher Donawa, Allan Kielstra, Igor Peshansky, Vivek Sarkar. Workshop on Programming Models for Ubiquitous Parallelism (PMUP), held in conjunction with PACT 2006, Sep 2006.X10 based on the Java Concurrency Utilities. Rajkishore Barik, Allan Kielstra, Vincent Cave, Igor Peshansky, Christopher Donawa, Vivek Sarkar. 2006 Workshop on Programming Models for Ubiquitous Parallelism,An Experiment in Measuring the Productivity of Three Parallel Programming Languages. Kemal Ebcioglu, VivekSarkar, Tarek El-Ghazawi, John Urbanic. HPCA Workshop on Productivity and Performance in High-End Computing (P- PHEC 2006), held in conjunction with HPCA 2006, Feb 2006.

2005X10: An Object-oriented approach to non-uniform Clustered Computing. Philip Charles, Christopher Donawa, KemalEbcioglu, Christian Grothoff, Allan Kielstra, Christoph von Praun, Vijay Saraswat, Vivek Sarkar. OOPSLA 2005.X10: an Experimental Language for High Productivity Programming of Scalable Systems. Kemal Ebcioglu, Vijay Saraswat, Vivek Sarkar. P-PHEC workshop, HPCA 2005.Concurrent Clustered Programming. Vijay Saraswat and Radha Jagadeesan, CONCUR 2005.

2004X10: Programming for hierarchical parallelism and non-uniform data access. Kemal Ebcioglu, Vijay Saraswat, VivekSarkar. International Workshop on Language Runtimes, OOPSLA 2004.

http://x10-lang.org/x10-community/publications-using-x10.html


まとめ：並列・分散プログラミング言語X10マルチコア時代のプログラミング環境に求められるもの

1. 大量の非同期タスクを軽量に生成・消滅できること．また，デッドロック等に悩まされずにタスク間の同期が行えること

非同期タスクは，async文により容易に生成可能で，デッドロックが起きないような構文上の工夫が行われている

2. 共有メモリ環境と分散メモリ環境を単一のプログラムで扱えること．また，異なるアーキテクチャの実行環境をサポートできること

実行モデルとして「APGAS」を採用し，言語レベルで「プレース」という概念を導入することで，共有メモリ環境と分散メモリ環境を単一のプログラムで扱える

3. 複数マシン間の複雑な通信処理を記述しなくてよいこと．しかし，並列処理や分散処理をある程度明示的に制御できること

プレース間の通信は，at文やDistArrayによって抽象化されており，プレースごとにアーキテクチャが異なっていてもかまわない

4. 開発をサポートするツール群が用意されていることEclipseベースの開発環境X10DTなど

Documents

X10lecture kawatiya 20111019 - IBM...2011/10/19 · 基本的にはJava風 – オブジェクト指向，静的な型付け – 単一継承（インタフェースは複数可）