Tiramisu をちょっと、味見してみました。

Tiramisu を
ちょこっと、味見してみました。
Halide勉強会＠フィックスターズ
2018/07/28(土)
@Vengineer
ロゴ：https://github.com/Tiramisu-Compiler/tiramisu/

ブログ (2007年～) : Vengineerの戯言
　http://blogs.yahoo.co.jp/verification_engineer
SlideShare :
　https://www.slideshare.net/ssuser479fa3
Twitter (2009年～) :
＠Vengineer
ソースコード解析職人

Tiramisu: A Code Optimization Framework for
High Performance Systems
https://www.csail.mit.edu/research/tiramisu-framework-code-optimizat
ion-and-code-generation
MIT CSAIL

Tiramisu Compiler
・(コード最適化 & コード生成) フレームワーク
・コード最適化 (ループ最適化)
　　=> 独自コンパイラに組み込み可能
　　=> loop tiling, loop fusion/distribution, loop spliting
　　　　loop interchange, loop shifting, loop unrolling
　　　　loop parallelization, loop vectorization
　　　　storage reordering, modulo storage
・コード生成
　　=> マルチCPU (LLVM)、GPU (CUDA)、
　　　　分散システム (MPI)、FPGA (Xilinx Vivado HLS)
https://github.com/Tiramisu-Colib/tiramisu#tiramisu-compiler

Tiramisuは、Halide & ISLを使っている
・Halide
https://github.com/halide/Halide
・ISL (Integer Set Library)
http://isl.gforge.inria.fr/
Facebook Research : Tensor Comprehensions
https://github.com/facebookresearch/TensorComprehensions
Tensor Comprehensions (TC) is a fully-functional C++ library to automatically
synthesize high-performance machine learning kernels
using Halide, ISL and NVRTC or LLVM.

Halide と Tiramisu の違い
Halideは、矩形領域のみサポート
Tiramisuは、矩形領域でなくても、OK!
何故なら？
　polyhedral representation (多面体表現) を使う！

4つのチャレンジ
1). MPI+OpenMP+CUDA+HLS
2). メモリ依存
3). 最適化と効率の良いコード生成
4). representation

4). representation
The challenge of representation is
addressed by using a unified framework based on
polyhedral sets to represent　the four layers.
「polyhedral sets」
よくわからないので、
誰か？教えてください

論文
を詳しく見てみよう

https://arxiv.org/pdf/1804.10694.pdf
コードをベタで書く

・Layer I : Abstract Algorithm
　・Layer II : Computation Management
　・Layer III : Data Management
　・Layer IV : Communication Managenent
　・Code generation: Abstract Syntax Tree

The first layer defines abstract computations,
which are not yet scheduled or mapped to memory.
Each computation represents an expression to compute.
Layer I : Abstract Algorithm

{b1(i, j, c) : 0 ≤ i < N ∧ 0 ≤ j < M ∧ 0 ≤ c < 3}
The iteration domain is the set of tuples b1(i, j, c) such that
0 ≤ i < N ∧ 0 ≤ j < M ∧ 0 ≤ c < 3
Iteration domain

Tiramisu でのコード生成では、次の2つのステップで行われる
1)、time-space mapping
　　　This mapping is done by applying an affine relation
2)、adding new statements.
Layer II, III, IV にて、コマンドを追加する
コード生成へのステップ

Affine transformations including loop tiling, skewing, loop fusion, distribution,
splitting, reordering, and many others can be expressed as an affine map that maps
computations from Layer I into the time-space domain in Layer II.
We call this map a time-space map.
Layer I の iteration domain を time-space domain に変換
Time-space Maps

Layer I：iteration domain
{C(i, j) : 0 ≤ i < N ∧ 0 ≤ j < N } : A(i, j) + B(i, j)
　Time-space mapping として、(16 x 16 tiles)　を！
{C(i, j) →C(i1, j1, i2, j2) : i1 = f loor (i/16) ∧ i2 = i%16∧
j1 = f loor (j/16) ∧ j2 = j%16 ∧ 0 ≤ i < N ∧ 0 ≤ j < N }
Layer II：time-space domain
{C(i1, j1, i2, j2) : i1 = f loor (i/16) ∧ i2 = i%16 ∧ j1 = f loor (j/16)∧j2 = j%16 ∧ 0 ≤
i < N ∧ 0 ≤ j < N } :
A(i1 ∗ 16 + i2, j1 ∗ 16 + j2) + B(i1 ∗ 16 + i2, j1 ∗ 16 + j2)
サンプル：Time-space Maps

Time dimensions : => When
実行の順番(他の computation に対して) を指定する
Space dimensions : => Where
各 computation を実行するプロセッサを指定する
Time-space domain (Time-space Maps)
Layer II: Computation Management

Space dimensions
各 computation を実行するプロセッサを指定する.
cpu 共有メモリシステム内のCPUで実行する
node 分散システム内のノードで実行する
gpu_thread_X GPUスレッドのX次元で実行する
gpu_block_X GPUブロックのX次元で実行する
vec(s) ベクタ化する ( s は、ベクタ幅 )
unroll アンロール
pipeline パイプライン化 ( FPGA のみ )
Layer II: Computation Management

Data Management では、計算結果を蓄えておくメモリの場所を指定する
allocation/deallocation statements
a set of access relations, which map a computation from Layer
II to array elements read or written by that computation.
Layer III: Data Management

通信コマンド(同期通信を含む)を追加およびスケジューリングされる
Layer IIIで追加した allocation or deallocation operation は、
Layer IVでスケジュールされる
Layer IV: Communication Management

テストコードを追っかけてみよう！

+
xxx.otest_XX wrapper_test_XX.o
wrapper_test_XX
このファイルに、
tiramisu のコードを書き、
オブジェクトファイル(xxx.o)を生成する
Tiramisuは、Halide と同様にオブジェクトファイルを生成し、その
オブジェクトファイルをリンクして使用します。

function
入力
Tiramisuは、ざっくり、こんな感じ
computation
computation
computation
computation
computation
bufferbuffer
出力

int main(int, char **)
{
Halide::Buffer<uint8_t> reference_buf(NN, MM);
init_buffer(reference_buf, (uint8_t)7);
Halide::Buffer<uint8_t> output_buf(NN, MM);
init_buffer(output_buf, (uint8_t)13);
assign_7_to_10x10_2D_array_with_tiling_parallelism(
output_buf.raw_buffer());
compare_buffers("assign_7_to_10x10_2D_array_with_tiling_parallelism",
output_buf, reference_buf);
return 0;
}
テストコード (tests/wrapper_test_01.cpp)
https://github.com/rbaghdadi/tiramisu/blob/master/tests/wrapper_test_01.cpp
この例は、resultのみ

オブジェクトファイルを生成
int main(int argc, char **argv)
{
generate_function_1(
"assign_7_to_10x10_2D_array_with_tiling_parallelism",
10, 3, 4);
return 0;
}
テストコード (tests/developers/test_01.cpp)
https://github.com/rbaghdadi/tiramisu/blob/master/tests/test_01.cpp#L41

void generate_function_1(std::string name, int size, int val0, int val1 )
{
tiramisu::global::set_default_tiramisu_options();
tiramisu::function function0(name);
tiramisu::constant N("N", tiramisu::expr((int32_t) size), p_int32, true,
NULL, 0, &function0 );
テストコード (tests/test_01.cpp)

static void set_default_tiramisu_options()
{
global::loop_iterator_type = p_int32;
set_auto_data_mapping(true);
// GPU : NVIDIA NVCCのパス
auto location = std::getenv(NVCC_BIN_DIR_ENV_VAR);
if (location)
nvcc_bin_dir = location;
}
global::set_default_tiramisu_optionsメソッド
https://github.com/rbaghdadi/tiramisu/blob/master/include/tiramisu/expr.h#L93

A class to represent functions in Tiramisu.
A function in Tiramisu is composed of a set of computations (tiramisu::computation).
例：
std::string name(“sample”);
tiramisu::function function0(name);
function クラス
https://github.com/rbaghdadi/tiramisu/blob/master/include/tiramisu/core.h#L97
computionsの集合！

A class that represents loop invariants.
An object of the invariant class can be an expression,
a symbolic constant
or a variable that is invariant to all the loops of the function.
例：
tiramisu::constant N("N", tiramisu::expr((int32_t) size),
p_int32, true, NULL, 0, &function0);
constant クラス

tiramisu::var i("i"), j("j"), i0("i0"), j0("j0"), i1("i1"), j1("j1");
tiramisu::expr e1 = tiramisu::expr(tiramisu::o_add,
tiramisu::expr((uint8_t) val0),
tiramisu::expr((uint8_t) val1) );
tiramisu::computation S0("[N]->{S0[i,j]: 0<=i<N and 0<=j<N}",
e1, true, p_uint8, &function0 );
tiramisu::buffer buf0("buf0", {size, size}, tiramisu::p_uint8,
a_output, &function0 );

A class that represents constant variable references
例：
tiramisu::var i("i"), j("j"), i0("i0"), j0("j0"), i1("i1"), j1("j1")
var クラス

A class to represent tiramisu expressions.
例：
tiramisu::expr e1 = tiramisu::expr(tiramisu::o_add,
tiramisu::expr((uint8_t) val0),
tiramisu::expr((uint8_t) val1));
expr クラス

A class that represents computations.
A computation is an expression associated with an iteration domain.
A computation indicates what needs to be computed
(the expression that should be computed).
A computation has three representations:
Level I
Level II
Level III
(最新の論文では、Layer I/II/III/IV と表現している。
Layer IVは、Communication Managenent)
computation クラス

例、
tiramisu::var i = tiramisu::var("i");
tiramisu::computation input("[N]->{input[i]}",
tiramisu::expr(), false,
p_uint8, &function0);
tiramisu::computation result("[N]->{result[0]}",
tiramisu::expr(input(0)), true,
result.add_definitions("[N]->{result[i]: 1<=i<N}",
(result(i - 1) + input(i)), true,
computation クラス

A class that represents buffers.
Buffers have two use cases:
- used to store the results of computations, and
- used to represent input arguments to functions.
例：入力バッファ
tiramisu::buffer input_buffer("input_buffer", {size},
tiramisu::p_uint8, a_input, &function0);
　　　　　　　　　　結果用のバッファ
tiramisu::buffer result_scalar("result_scalar", {1},
tiramisu::p_uint8, a_output, &function0);
buffer クラス

S0.set_access("{S0[i,j]->buf0[i,j]}");
S0.tile(i, j, 2, 2, i0, j0, i1, j1);
S0.tag_parallel_level(i0);

void set_access(std::string access_str);
void set_access(isl_map *access);
Set the access relation of the computation.
The access relation is a relation from computations to buffer
locations. access_str is a string that represents the relation.
It is encoded in the ISL format,
(http://isl.gforge.inria.fr/user.html#Sets-and-Relations)
例、
S0.set_access("{S0[i,j]->buf0[i,j]}");
computation::set_access メソッド

void tile(tiramisu::var L0, tiramisu::var L1, int sizeX, int sizeY,
tiramisu::var L0_outer, tiramisu::var L1_outer,
tiramisu::var L0_inner, tiramisu::var L1_inner );
Tile the two loop levels L0 and L1 with rectangular tiling.
sizeX and sizeY represent the tile size.
L0 and L1 should be two consecutive loop levels.
L0_outer, L1_outer, L0_inner, L1_inner are the names
of the new dimensions created after tiling.
例、
S0.tile(i, j, 2, 2, i0, j0, i1, j1);
computation::tile メソッド

void tag_parallel_level(tiramisu::var L);
void tag_parallel_level(int L);
Tag the loop level L to be parallelized.
例、
S0.tag_parallel_level(i0);
computation::tag_parallel_level メソッド

// 引数 (buf0) を設定
function0.set_arguments({&buf0});
// interation domain => time-space domain
function0.gen_time_space_domain();
// ISLのAbstract Syntax Treeを生成
function0.gen_isl_ast();
// Halide Statement を生成
function0.gen_halide_stmt();
// オブジェクトファイルの生成
function0.gen_halide_obj("build/generated_fct_test_01.o");
}

void set_arguments(const std::vector<tiramisu::buffer *> &buffer_vec );
Set the arguments of the function.
The arguments of the function are provided as a vector of
pointers to buffers. Each buffer represents an argument
to the function.
During code generation, the arguments in the vector will
become the arguments of the generated function
(with the order of their appearance in the vector).
function::set_arguments メソッド

void gen_time_space_domain();
Generate the time-space domain of the function.
In this representation, the logical time of execution
and the processor where the computation
will be executed are both specified.
function::gen_time_space_domain メソッド

void gen_isl_ast();
Generate an isl AST that represents the function.
function::gen_isl_ast メソッド

void gen_halide_stmt();
Generate a Halide stmt that represents the function.
function::gen_halide_stmt メソッド

void gen_halide_obj(const std::string &obj_file_name,
Halide::Target::OS os,
Halide::Target::Arch arch, int bits ) const;
Generate an object file that contains the compiled function.
This function relies on Halide to generate the object file.
obj_file_name : the name of the generated file.
os : the target operating system (Halide::Target::OS).
arch : the architecture of the target (the instruction set).
bits : the bit-width of the target machine.
(must be 0 for unknown, or 32 or 64 )
function::gen_halide_obj メソッド

void tiramisu::function::codegen(
const std::vector<tiramisu::buffer *> &buffer_vec,
const std::string obj_filename) {
this->set_arguments(buffer_vec);
this->lift_dist_comps(); // <= MPI/CUDAの時のみ有効
this->gen_time_space_domain();
this->gen_isl_ast();
this->gen_halide_stmt();
this->gen_halide_obj(obj_filename);
}
全部まとめでコード生成 function::codegen
https://github.com/Tiramisu-Colib/tiramisu/blob/master/src/tiramisu_core.cpp#L8508

実は、ここまでは、
Low Level Tiramisu API

Tiramisu expressions
って、何？

// C++ code with a Tiramisu expression.
#include "tiramisu.h"
void foo(int N, int array_a[N], int array_b[N], int array_c[N])
{
tiramisu::init();
// Declare an iterator and inputs
tiramisu::iter i, j;
tiramisu::in A(i,j), B(i,j);
Tiramisu expressions (README.md)
https://github.com/Tiramisu-Compiler/tiramisu/blob/master/README.md#example

// Declare the Tiramisu expression (algorithm)
tiramisu::comp C(i,j) = A(i,j) + B(i,j);
// Specify optimizations
C.parallelize(i).vectorize(j, 4);
// Realize, compile and run the expression
C.realize(tiramisu::int32_t, {N});
C.compile({(A, array_a), (B, array_b), (C, array_c)});
C.run();
}
Tiramisu expressions (README.md)
https://github.com/Tiramisu-Compiler/tiramisu/blob/master/README.md#example

あー、なんか、Halide っぽいね。
でも、実装コードは、
まだ、ありません

コードをベタで書く DSL Compiler
が無いと
え、もしかして、
Tiramisu expressions
のこと？

ブログ (2007年～) : Vengineerの戯言
　http://blogs.yahoo.co.jp/verification_engineer
SlideShare :
　https://www.slideshare.net/ssuser479fa3
ありがとうございました
Twitter (2009年～) :
＠Vengineer
ソースコード解析職人

virtual void add_definitions(std::string iteration_domain_str, tiramisu::expr e,
bool schedule_this_computation, tiramisu::primitive_t t,
tiramisu::function *fct );
Add definitions of computations that have the same name as this
computation.
The arguments of this function are identical to the arguments of
the computation constructor.
In general, this function is used to express reductions
and to express computation updates.
function::add_definitions メソッド

例、
// [N]->{C[0,i]: 0<=i<N} : 10
tiramisu::computation C("[N]->{C[0,i]: 0<=i<N}",
tiramisu::expr((uint8_t) 10), true,
// [N]->{C[1,i]: 0<=i<N} : C(0, i) + 10
C.add_definitions("[N]->{C[1,i]: 0<=i<N}",
C(0, i) + tiramisu::expr((uint8_t) 10), true,
function::add_definitions メソッド

tiramisu::computation& get_update(int index);
Returns the index update that has been added to this computation such that:
- If index == 0, then this computation is returned.
- If > 0, then it returns the pth computation added
through add_definitions.
function::get_update メソッド

例、
tiramisu::computation result("[N]->{result[0]}",
tiramisu::expr(input(0)), true, p_uint8, &function0 );
result.add_definitions("[N]->{result[i]: 1<=i<N}",
(result(i - 1) + input(i)), true, p_uint8, &function0 );
// result.get_update(1)は、result[1]になる
// result[0] を先に実行してから、result[i]を実行する
result.get_update(1).after(result, computation::root);
function::get_update メソッド
https://github.com/rbaghdadi/tiramisu/blob/master/tutorials/tutorial_06.cpp

void tiramisu::computation::set_expression(const tiramisu::expr &e );
Set the expression of the computation.
例、
computation c_C("[N]->{c_C[i,j,0]: 0<=i<N and 0<=j<N}",
expr((uint8_t) 0), true, p_uint8, &matmul );
c_C.add_definitions("[N]->{c_C[i,j,k]: 0<=i<N and 0<=j<N and 0<=k<N}",
expr(), true, p_uint8, &matmul );
expr e1 = c_C(i, j, k - 1) + c_A(i, k) * c_B(k, j);
c_C.get_update(1).set_expression(e1);
computation::set_expression メソッド
https://github.com/rbaghdadi/tiramisu/blob/master/src/tiramisu_core.cpp#L7470

void after(computation &comp, tiramisu::var iterator);
Schedule this computation to run after the computation comp.
This computation is placed after comp in the loop level level.
level is a loop level in this computation.
computation::after メソッド

例、
{S0[i,j]: 0<=i<N and 0<=j<N} and {S1[i,j]: 0<=i<N and 0<=j<N}
S1.after(S0, i)
for (i=0; i<N; i++)
{
for (j=0; j<N; j++)
S0;
for (j=0; j<N; j++)
S1;
}

例、
S1.after(S0, j)
for (i=0; i<N; i++)
for (j=0; j<N; j++)
{
S0;
S1;
}

例、
S1.after(S0, computation::root)
for (i=0; i<N; i++)
for (j=0; j<N; j++)
S0;
for (i=0; i<N; i++)
for (j=0; j<N; j++)
S1;

例、
{S0[i,j]: 0<=i<N and 0<=j<N}, {S1[i,j]: 0<=i<N and 0<=j<N}
and {S2[i,j]: 0<=i<N and 0<=j<N}.
for (i=0; i<N; i++)
for (j=0; j<N; j++)
S0;
for (i=0; i<N; i++)
for (j=0; j<N; j++)
S1;
for (i=0; i<N; i++)
for (j=0; j<N; j++)
S2;
computation::fuse_after メソッド

例、
S2.fuse_after(j, S1);
S1.fuse_after(j, S0);
for (i=0; i<N; i++)
for (j=0; j<N; j++)
{
S0;
S1;
S2;
}

例、
S2.fuse_after(i, S1);
S1.fuse_after(i, S0);
for (i=0; i<N; i++)
{
for (j=0; j<N; j++)
S0;
for (j=0; j<N; j++)
S1;
for (j=0; j<N; j++)
S2;
}

void before(computation &consumer, tiramisu::var L);
Schedule this computation to run
before the computation consumer at the loop level L
computation::before メソッド

void between(computation &before_comp, tiramisu::var before_l,
computation &after_comp, tiramisu::var after_l );
Schedule this computation to run
after before_comp at the loop level before_l,
and before after_comp at loop level after_l.
The outermost loop level is 0.
computation::between メソッド

void bind_to(buffer *buff);
Bind this computation to a buffer. i.e., create a one-to-one data
mapping between the computation and the buffer.
In Tiramisu, a tiramisu computation cannot directly consume
values from buffers.
Buffers should first be wrapped in computations.
computation::bind_to メソッド

例、
tiramisu::buffer N_input_b("N_input_b", {1},
tiramisu::p_int32, a_input, &function0 );
N_input.bind_to(&N_input_b);
tiramisu::buffer S0_b("S0_b", {N_input(0), N_input(0)},
tiramisu::p_uint8, a_temporary, &function0 );
S0.bind_to(&S0_b);
tiramisu::buffer S1_b("S1_b", {tiramisu::var("N"), tiramisu::var("N")},
tiramisu::p_uint8, a_output, &function0 );
S1.bind_to(&S1_b);
computation::bind_to メソッド
https://github.com/rbaghdadi/tiramisu/blob/master/tests/test_87.cpp

void compute_at(computation &consumer, tiramisu::var L );
void compute_at(computation &consumer, int L );
void interchange(tiramisu::var L0, tiramisu::var L1 );
void set_inline(bool is_inline = true );
computation クラスのいろいろなメソッド
https://github.com/rbaghdadi/tiramisu/blob/master/include/tiramisu/core.h

void shift(tiramisu::var L0, int n );
void split(tiramisu::var L0, int sizeX );
void split(tiramisu::var L0, int sizeX, tiramisu::var L0_outer, tiramisu::var L0_inner );
void tile(int L0, int L1, int sizeX, int sizeY );
void tile(int L0, int L1, int L2, int sizeX, int sizeY, int sizeZ );
void unroll(tiramisu::var L, int fac );
void unroll(tiramisu::var L, int fac, tiramisu::var L_outer, tiramisu::var L_inner );
void vectorize(tiramisu::var L, int v );
void vectorize(tiramisu::var L, int v, tiramisu::var L_outer, tiramisu::var L_inner );
computation クラスのいろいろなメソッド
https://github.com/rbaghdadi/tiramisu/blob/master/include/tiramisu/core.h

Tiramisu をちょっと、味見してみました。

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Tiramisu をちょっと、味見してみました。

Semelhante a Tiramisu をちょっと、味見してみました。 (20)

Mais de Mr. Vengineer

Mais de Mr. Vengineer (20)

Último

Último (20)

Tiramisu をちょっと、味見してみました。