12_schedule_program.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 准备工作\n",
    "\n",
    "首先列出原始代码, 因为原始代码并不是c的形式, 所以这里手动列出所多面体所需要的各项信息:\n",
    "```python\n",
    "for i in range(1,1000):\n",
    "  for j in range(1,500):\n",
    "    a[i, j] = a[i, j+1] + b[i, j] # s1\n",
    "    c[i, j] = a[i, j] + d[i+1, j] # s2\n",
    "    d[i, j] = 3*e[i, j] # s3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "import isl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "domain = isl.union_set(\"{ s1[i, j] : 1 <= i < 1000 and 1 <= j < 500; s2[i, j] : 1 <= i < 1000 and 1 <= j < 500; s3[i, j] : 1 <= i < 1000 and 1 <= j < 500 }\")\n",
    "schedule = isl.union_map(\"{ s1[i,j] -> [t0 = i, t1 = j, t2 = 0]; s2[i,j] -> [t0 = i, t1 = j, t2 = 1]; s3[i,j] -> [t0 = i, t1 = j, t2 = 2] }\")\n",
    "reads = isl.union_map(\"{ s1[i,j] -> a[i,j+1]; s1[i,j] -> b[i,j]; s2[i, j] -> a[i,j]; s2[i, j] -> d[i+1,j]; s3[i, j] -> e[i,j];  }\")\n",
    "writes = isl.union_map(\"{ s1[i,j] -> a[i,j]; s2[i, j] -> c[i,j]; s3[i, j] -> d[i,j];  }\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "domain: { s3[i, j] : 0 < i <= 999 and 0 < j <= 499; s2[i, j] : 0 < i <= 999 and 0 < j <= 499; s1[i, j] : 0 < i <= 999 and 0 < j <= 499 }\n",
      "schedule: { s3[i, j] -> [t0 = i, t1 = j, t2 = 2]; s1[i, j] -> [t0 = i, t1 = j, t2 = 0]; s2[i, j] -> [t0 = i, t1 = j, t2 = 1] }\n",
      "reads: { s1[i, j] -> b[i, j]; s3[i, j] -> e[i, j]; s1[i, j] -> a[i, 1 + j]; s2[i, j] -> a[i, j]; s2[i, j] -> d[1 + i, j] }\n",
      "writes: { s2[i, j] -> c[i, j]; s3[i, j] -> d[i, j]; s1[i, j] -> a[i, j] }\n"
     ]
    }
   ],
   "source": [
    "print(\"domain:\", domain)\n",
    "print(\"schedule:\", schedule)\n",
    "print(\"reads:\", reads)\n",
    "print(\"writes:\", writes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 依赖分析\n",
    "\n",
    "## 写后读依赖\n",
    "\n",
    "$$(R ^{-1} \\circ W)\\ \\cap < S$$\n",
    "\n",
    "Read After Write(RAW)依赖也被称为流依赖/真依赖, 需要保证前一个操作写入后才能进行正确读取, 对应计算机中常说的生产-消费关系. 也就是读语句作为`sink`节点, 写语句作为`source`节点, 我们可以用两种不同的api来计算写后读依赖."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "read after write: { s1[i, j] -> s2[i' = i, j' = j] }\n",
      "last write -> read { s1[i, j] -> [s2[i' = i, j' = j] -> a[i, j]] }\n"
     ]
    }
   ],
   "source": [
    "raw = writes.apply_range(reads.reverse()).intersect(schedule.lex_lt_union_map(schedule))\n",
    "print(\"read after write:\",raw)\n",
    "\n",
    "info = isl.union_access_info(reads)\n",
    "info = info.set_must_source(writes)\n",
    "info = info.set_schedule_map(schedule)\n",
    "flow = info.compute_flow()\n",
    "print(\"last write -> read\", flow.full_must_dependence())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在同一个`[i,j]`迭代下, `s1`对某个数据的写入后被`s2`读取."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 读后写依赖\n",
    "\n",
    "$$(W ^{-1} \\circ R)\\ \\cap < S$$\n",
    "\n",
    "Write After Read(WAR)依赖也被称为反依赖, 此时写语句作为`sink`节点, 读语句作为`source`节点."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "write after read: { s2[i, j] -> s3[i' = 1 + i, j' = j]; s1[i, j] -> s1[i' = i, j' = 1 + j] }\n",
      "last read -> write { s2[i, j] -> [s3[i' = 1 + i, j' = j] -> d[1 + i, j]]; s1[i, j] -> [s1[i' = i, j' = 1 + j] -> a[i, 1 + j]] }\n"
     ]
    }
   ],
   "source": [
    "war = reads.apply_range(writes.reverse()).intersect(schedule.lex_lt_union_map(schedule))\n",
    "print(\"write after read:\",war)\n",
    "\n",
    "info = isl.union_access_info(writes)\n",
    "info = info.set_must_source(reads)\n",
    "info = info.set_schedule_map(schedule)\n",
    "flow = info.compute_flow()\n",
    "print(\"last read -> write\", flow.full_must_dependence())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在`[i,j]`迭代中`s2`读取后, 在`[i+1,j]`迭代中`s3`中对同一位置进行覆盖写入. 在`[i,j]`迭代中`s1`读取后, 在`[i,j+1]`迭代中`s1`中对同一位置进行覆盖写入."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 写后写依赖\n",
    "\n",
    "$$(W ^{-1} \\circ W)\\ \\cap < S$$\n",
    "\n",
    "Write After Write也称为输出依赖, 此时最新的写入作为`sink`节点, 上一次写入作为`source`节点.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "write after write: {  }\n",
      "last write -> current write {  }\n"
     ]
    }
   ],
   "source": [
    "waw = writes.apply_range(writes.reverse()).intersect(schedule.lex_lt_union_map(schedule))\n",
    "print(\"write after write:\",waw)\n",
    "\n",
    "info = isl.union_access_info(writes)\n",
    "info = info.set_must_source(writes)\n",
    "info = info.set_schedule_map(schedule)\n",
    "flow = info.compute_flow()\n",
    "print(\"last write -> current write\", flow.full_must_dependence())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在数据流分析和依赖关系的上下文中, `sink`(汇点)和 `source`(源点)的概念是用来描述数据如何在不同的操作间流动的.依赖关系通常是从 `source` 到 `sink` 的, 这表示数据从 `source` 产生并流向 `sink`. 这个概念在不同类型的依赖中有所不同: \n",
    "\n",
    "1. 写后读(Write-After-Read, WAR)/ 真依赖(True Dependency): \n",
    "    - Source: 写操作, 因为它产生了数据.\n",
    "    - Sink: 随后的读操作, 因为它使用了前面写操作产生的数据.\n",
    "    - 依赖方向: 从写操作(source)到读操作(sink).\n",
    "2. 读后写(Read-After-Write, RAW)/ 反依赖(Anti-dependency): \n",
    "    - Source: 读操作, 因为它首先访问了数据.\n",
    "    - Sink: 随后的写操作, 因为它可能会改变前面读操作访问的数据.\n",
    "    - 依赖方向: 从读操作(source)到写操作(sink).\n",
    "3. 写后写(Write-After-Write, WAW)/ 输出依赖(Output Dependency): \n",
    "    - Source: 第一个写操作, 因为它首先写入数据.\n",
    "    - Sink: 随后的写操作, 因为它写入相同的数据位置.\n",
    "    - 依赖方向: 从第一个写操作(source)到第二个写操作(sink).\n",
    "\n",
    "使用`union_access_info`计算出`union_flow`之后, 我们可以获取以下一些信息:\n",
    "\n",
    "- must_dependence/full_must_dependence\n",
    "- may_dependence/full_may_dependence\n",
    "- must_no_source/may_no_source\n",
    "\n",
    "这里带有`full`表示输出中带有对具体数组访问的信息.带有`may`前缀的表示无法确定的信息. \n",
    "\n",
    "这里`no_source`表示没有来源的实例, 比如例子中对于数组`c`只有写入没有读取, 例如在读后写依赖中,读作为`soure`, 这里的`no source`依赖为`{ s2[i, j] -> c[i, j] }`, 因为没有对数组`c`的写入只有对他的读取. 而对于写后读依赖, 这里的`no source`依赖为:`{ s1[i, j] -> b[i, j]; s3[i, j] -> e[i, j]; s2[i, j] -> d[1 + i, j]; s1[i, j] -> a[i, 1 + j] }`, 我们也可以称之为`live in memory`, 也就是在这段代码中只从外部读取的数据."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 自动并行优化\n",
    "\n",
    "通过观察依赖可以发现, 在这里存在了跨迭代的读后写依赖, 影响了这段代码的并行化. 因此我们需要考虑寻找合适的方法来消除这种依赖. \n",
    "在isl库中, 提供了`schedule_constraints`用于自动地构建和操作调度约束, 默认使用类似`pluto`的调度算法. 我们可以给他提供迭代域, `validity`(有效性依赖, 用于保证程序正确性), `proximity`(临近性依赖, 用于提升局部性), `coincidence`(相干性依赖, 用于提示并行性). \n",
    "\n",
    "然后使用`compute_schedule`函数可以用来计算满足给定调度约束的调度. 这些调度约束包括计算调度所需的迭代域以及迭代对之间的依赖. 生成的调度将遵守所有有效性依赖，确保这些依赖在调度空间中的依赖距离是字典序上的正值​​. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# YOU ARE HERE\n",
      "domain: \"{ s3[i, j] : 0 < i <= 999 and 0 < j <= 499; s2[i, j] : 0 < i <= 999 and 0 < j <= 499; s1[i, j] : 0 < i <= 999 and 0 < j <= 499 }\"\n",
      "child:\n",
      "  schedule: \"[{ s3[i, j] -> [(i)]; s2[i, j] -> [(1 + i)]; s1[i, j] -> [(1 + i)] }, { s3[i, j] -> [(j)]; s2[i, j] -> [(j)]; s1[i, j] -> [(j)] }]\"\n",
      "  permutable: 1\n",
      "  coincident: [ 1, 0 ]\n",
      "  child:\n",
      "    sequence:\n",
      "    - filter: \"{ s1[i, j] }\"\n",
      "    - filter: \"{ s2[i, j] }\"\n",
      "    - filter: \"{ s3[i, j] }\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "sc = isl.schedule_constraints.on_domain(domain)\n",
    "dep = war.union(raw).union(waw)\n",
    "sc = sc.set_validity(dep)\n",
    "sc = sc.set_coincidence(dep)\n",
    "sc = sc.set_proximity(dep)\n",
    "sched = sc.compute_schedule()\n",
    "print(sched.root())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里我们需要利用`band`节点的coincident信息在后续codegen是生成带有并行的代码, 但是在isl中内置的循环类型只有`isl_ast_loop_default,isl_ast_loop_atomic,isl_ast_loop_unroll,isl_ast_loop_separate`这四种, 并且都是会在codegen时有单独的处理, 所以我们只能自己添加`mark`节点到图上, 给后续使用. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert_mark_before_bind(node: isl.schedule_node) -> isl.schedule_node:\n",
    "    if (isinstance(node, isl.schedule_node_band)):\n",
    "        bind: isl.schedule_node_band = node\n",
    "        splited_bind = None\n",
    "        new_bind = bind\n",
    "        while True:\n",
    "            splited = False\n",
    "            for i in range(new_bind.n_member()):\n",
    "                if (new_bind.member_get_coincident(i)):\n",
    "                    new_bind = new_bind.split(i+1)\n",
    "                    new_bind = new_bind.insert_mark(isl.id(f\"parallel\"))\n",
    "                    if splited_bind is None:\n",
    "                        splited_bind = new_bind\n",
    "                    new_bind = new_bind.child(0).child(0)\n",
    "                    splited = True\n",
    "                    break\n",
    "            if (not splited):\n",
    "                break\n",
    "\n",
    "        return bind if splited_bind is None else splited_bind\n",
    "    return node\n",
    "\n",
    "\n",
    "# post order visit\n",
    "new_sched = sched.map_schedule_node_bottom_up(insert_mark_before_bind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "isl.schedule_node_domain(\"\"\"# YOU ARE HERE\n",
       "domain: \"{ s3[i, j] : 0 < i <= 999 and 0 < j <= 499; s2[i, j] : 0 < i <= 999 and 0 < j <= 499; s1[i, j] : 0 < i <= 999 and 0 < j <= 499 }\"\n",
       "child:\n",
       "  mark: \"parallel\"\n",
       "  child:\n",
       "    schedule: \"[{ s3[i, j] -> [(i)]; s2[i, j] -> [(1 + i)]; s1[i, j] -> [(1 + i)] }]\"\n",
       "    permutable: 1\n",
       "    coincident: [ 1 ]\n",
       "    child:\n",
       "      schedule: \"[{ s3[i, j] -> [(j)]; s2[i, j] -> [(j)]; s1[i, j] -> [(j)] }]\"\n",
       "      permutable: 1\n",
       "      child:\n",
       "        sequence:\n",
       "        - filter: \"{ s1[i, j] }\"\n",
       "        - filter: \"{ s2[i, j] }\"\n",
       "        - filter: \"{ s3[i, j] }\"\n",
       "\"\"\")"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_sched.root()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于添加`mark`节点后的调度树, 首先我们将他转换为`ast tree`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def after_mark_callback(node: isl.ast_node_mark, build: isl.ast_build) -> isl.ast_node:\n",
    "    if (node.id().name() == \"parallel\"):\n",
    "      mark_child: isl.ast_node  = node.node()\n",
    "      mark_child = mark_child.set_annotation(isl.id(\"parallel\"))\n",
    "      # NOTE isl内部应该有bug,如果root节点为ast for, 那么后续遍历时无法遍历到root for ast node. 所以这里手动添加一个block\n",
    "      return isl.ast_node_block(isl.ast_node_list(isl.ast_node(mark_child))) \n",
    "    return node\n",
    "\n",
    "\n",
    "builder = isl.ast_build()\n",
    "builder = builder.set_after_each_mark(after_mark_callback)\n",
    "tree: isl.ast_node = builder.node_from(new_sched)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来需要处理两个事情, 一个是statement的表达式生成, 另一个就是并行循环生成, 这里都使用`callback`来处理:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class='code'><code class=\"cpp hljs\">{\n",
       "  #pragma omp parallel for\n",
       "  for (int c0 = 1; c0 <= 1000; c0 += 1)\n",
       "    for (int c1 = 1; c1 <= 499; c1 += 1) {\n",
       "      if (c0 >= 2) {\n",
       "        a[c0 - 1][c1] = a[c0 - 1][c1 + 1] + b[c0 - 1][c1];\n",
       "        c[c0 - 1][c1] = a[c0 - 1][c1] + d[c0 - 1 + 1][c1];\n",
       "      }\n",
       "      if (c0 <= 999)\n",
       "        d[c0][c1] = 3 * e[c0][c1];\n",
       "    }\n",
       "}\n",
       "</code></pre>"
      ],
      "text/plain": [
       "```c\n",
       "{\n",
       "  #pragma omp parallel for\n",
       "  for (int c0 = 1; c0 <= 1000; c0 += 1)\n",
       "    for (int c1 = 1; c1 <= 499; c1 += 1) {\n",
       "      if (c0 >= 2) {\n",
       "        a[c0 - 1][c1] = a[c0 - 1][c1 + 1] + b[c0 - 1][c1];\n",
       "        c[c0 - 1][c1] = a[c0 - 1][c1] + d[c0 - 1 + 1][c1];\n",
       "      }\n",
       "      if (c0 <= 999)\n",
       "        d[c0][c1] = 3 * e[c0][c1];\n",
       "    }\n",
       "}\n",
       "\n",
       "```"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from utils.common import CSource\n",
    "\n",
    "\n",
    "def print_for_callback(p: isl.printer, opt: isl.ast_print_options, node: isl.ast_node_for):\n",
    "    anno = node.get_annotation()\n",
    "    if (anno.ptr is not None and anno.name() == \"parallel\"):\n",
    "        p.start_line()\n",
    "        p.print_str(\"#pragma omp parallel for\")\n",
    "        p.end_line()\n",
    "    node.print(p, opt)\n",
    "    return p\n",
    "\n",
    "\n",
    "def print_user_callback(p: isl.printer, opt: isl.ast_print_options, node: isl.ast_node_user):\n",
    "    e = node.expr()\n",
    "    if isinstance(e, isl.ast_expr_op_call):\n",
    "        sid: isl.ast_expr_id = e.arg(0)\n",
    "        i, j = e.arg(1), e.arg(2)\n",
    "        idname = sid.id().name()\n",
    "        if (idname == \"s1\"):\n",
    "            # a[i, j] = a[i, j+1] + b[i, j] # s1\n",
    "            a = isl.ast_expr.from_id(isl.id(\"a\"))\n",
    "            b = isl.ast_expr.from_id(isl.id(\"b\"))\n",
    "            l = isl.ast_expr_list(2)\n",
    "            l = l.add(i)\n",
    "            l = l.add(j.add(isl.ast_expr.from_val(isl.val(1))))\n",
    "            lhs = isl.ast_expr.access(a, l)\n",
    "            \n",
    "            l = isl.ast_expr_list(2)\n",
    "            l = l.add(i)\n",
    "            l = l.add(j)\n",
    "            rhs = isl.ast_expr.access(b, l)\n",
    "\n",
    "            left = lhs.add(rhs)\n",
    "\n",
    "            l = isl.ast_expr_list(2)\n",
    "            l = l.add(i)\n",
    "            l = l.add(j)\n",
    "            right = isl.ast_expr.access(a, l)\n",
    "            p.start_line()\n",
    "            p.print_ast_expr(right)\n",
    "            p.print_str(\" = \")\n",
    "            p.print_ast_expr(left)\n",
    "            p.print_str(\";\")\n",
    "            p.end_line()\n",
    "        elif idname == \"s2\":\n",
    "            # c[i, j] = a[i, j] + d[i+1, j] # s2\n",
    "            a = isl.ast_expr.from_id(isl.id(\"a\"))\n",
    "            c = isl.ast_expr.from_id(isl.id(\"c\"))\n",
    "            d = isl.ast_expr.from_id(isl.id(\"d\"))\n",
    "            ij = isl.ast_expr_list(2)\n",
    "            ij = ij.add(i)\n",
    "            ij = ij.add(j)\n",
    "            \n",
    "            i1j = isl.ast_expr_list(2)\n",
    "            i1j = i1j.add(i.add(isl.ast_expr.from_val(isl.val(1))))\n",
    "            i1j = i1j.add(j)\n",
    "            p.start_line()\n",
    "            p.print_ast_expr(c.access(ij))\n",
    "            p.print_str(\" = \")\n",
    "            p.print_ast_expr(a.access(ij).add(d.access(i1j)))\n",
    "            p.print_str(\";\")\n",
    "            p.end_line()\n",
    "        elif idname == \"s3\":\n",
    "            # d[i, j] = 3*e[i, j] # s3\n",
    "            d = isl.ast_expr.from_id(isl.id(\"d\"))\n",
    "            e = isl.ast_expr.from_id(isl.id(\"e\"))\n",
    "            ij = isl.ast_expr_list(2)\n",
    "            ij = ij.add(i)\n",
    "            ij = ij.add(j)\n",
    "            \n",
    "            p.start_line()\n",
    "            p.print_ast_expr(d.access(ij))\n",
    "            p.print_str(\" = \")\n",
    "            p.print_ast_expr(isl.ast_expr.from_val(3).mul(e.access(ij)))\n",
    "            p.print_str(\";\")\n",
    "            p.end_line()\n",
    "    return p\n",
    "\n",
    "\n",
    "printer = isl.printer.to_file_path('/tmp/1.c')\n",
    "printer.set_output_format(isl.format.C)\n",
    "\n",
    "options = isl.ast_print_options.alloc()\n",
    "options = options.set_print_for(print_for_callback)\n",
    "options = options.set_print_user(print_user_callback)\n",
    "tree.print(printer, options)\n",
    "printer.flush()\n",
    "\n",
    "CSource('/tmp/1.c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 手动并行优化\n",
    "\n",
    "我们需要考虑哪些依赖是跨迭代的, 通过消除跨迭代的依赖性来进行并行化. 首先我们选取迭代域的子集绘制两个写后读依赖图:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plot.plotter import plot_map "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ s1[i, j] -> s1[i' = i, j' = 1 + j] : 0 < i <= 9 and 0 < j <= 4 }\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "partial_domain = isl.set(\"{s1[i, j] : 1 <= i < 10 and 1 <= j < 5 }\")\n",
    "s1 = war.map_list().at(1)\n",
    "s1_point_map = s1.intersect_domain(partial_domain)\n",
    "print(s1_point_map)\n",
    "plot_map(s1_point_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ s2[i, j] -> s3[i' = 1 + i, j' = j] : 0 < i <= 9 and 0 < j <= 4 }\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "partial_domain = isl.set(\"{s2[i, j] : 1 <= i < 10 and 1 <= j < 5 }\")\n",
    "s2 = war.map_list().at(0)\n",
    "s2_point_map = s2.intersect_domain(partial_domain)\n",
    "print(s2_point_map)\n",
    "plot_map(s2_point_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上图表示在迭代`i`上, `s1`不存在跨迭代依赖. 在迭代`j`上`s2`并不存在跨迭代依赖. 那么说明我们可以考虑对迭代`i`或`j`中进行并行可能性. 迭代`i`在迭代`j`的外部, 如果对迭代`i`进行并行, `s2`上存在跨迭代的依赖会导致错误. \n",
    "\n",
    "注意到迭代`j`中只有`s1`存在依赖, 而其他两个语句不存在依赖, 那么我们可以通过`Loop Fission`拆分迭代`j`的语句, 单独对`s2,s3`的进行并行化.\n",
    "\n",
    "接下来我们手动构造一个拆分后的调度树:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "sched2 = isl.schedule.from_domain(domain)\n",
    "root = sched2.root()\n",
    "c0 =  root.child(0).insert_partial_schedule(isl.multi_union_pw_aff(\"[{ s3[i, j] -> [(i)]; s2[i, j] -> [(i)]; s1[i, j] -> [(i)] }]\"))\n",
    "c1 = c0.child(0).insert_sequence(isl.union_set_list(\"({ s1[i, j] }, { s2[i, j]; s3[i, j] })\"))\n",
    "c2 = c1.child(0).child(0).insert_partial_schedule(isl.multi_union_pw_aff(\"[{ s1[i, j] -> [j] }]\"))\n",
    "c2 = c2.child(0).insert_sequence(isl.union_set_list(\"({ s1[i, j] })\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "isl.schedule_node_sequence(\"\"\"domain: \"{ s3[i, j] : 0 < i <= 999 and 0 < j <= 499; s2[i, j] : 0 < i <= 999 and 0 < j <= 499; s1[i, j] : 0 < i <= 999 and 0 < j <= 499 }\"\n",
       "child:\n",
       "  schedule: \"[{ s2[i, j] -> [(i)]; s1[i, j] -> [(i)]; s3[i, j] -> [(i)] }]\"\n",
       "  child:\n",
       "    sequence:\n",
       "    - filter: \"{ s1[i, j] }\"\n",
       "      child:\n",
       "        schedule: \"[{ s1[i, j] -> [(j)] }]\"\n",
       "        child:\n",
       "          sequence:\n",
       "          - filter: \"{ s1[i, j] }\"\n",
       "    - filter: \"{ s3[i, j]; s2[i, j] }\"\n",
       "      child:\n",
       "        mark: \"parallel\"\n",
       "        child:\n",
       "          schedule: \"[{ s3[i, j] -> [(j)]; s2[i, j] -> [(j)] }]\"\n",
       "          child:\n",
       "            # YOU ARE HERE\n",
       "            sequence:\n",
       "            - filter: \"{ s2[i, j] }\"\n",
       "            - filter: \"{ s3[i, j] }\"\n",
       "\"\"\")"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c3 = c2.parent().parent().parent().child(1).child(0).insert_mark(isl.id(\"parallel\")).child(0).insert_partial_schedule(isl.multi_union_pw_aff(\"[{ s3[i, j] -> [j]; s2[i, j] -> [j] }]\"))\n",
    "c3 = c3.child(0).insert_sequence(isl.union_set_list(\"({ s2[i, j] }, { s3[i, j] })\"))\n",
    "c3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对调度树进行代码生成:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class='code'><code class=\"cpp hljs\">for (int c0 = 1; c0 <= 999; c0 += 1) {\n",
       "  for (int c1 = 1; c1 <= 499; c1 += 1)\n",
       "    a[c0][c1] = a[c0][c1 + 1] + b[c0][c1];\n",
       "  #pragma omp parallel for\n",
       "  for (int c1 = 1; c1 <= 499; c1 += 1) {\n",
       "    c[c0][c1] = a[c0][c1] + d[c0 + 1][c1];\n",
       "    d[c0][c1] = 3 * e[c0][c1];\n",
       "  }\n",
       "}\n",
       "</code></pre>"
      ],
      "text/plain": [
       "```c\n",
       "for (int c0 = 1; c0 <= 999; c0 += 1) {\n",
       "  for (int c1 = 1; c1 <= 499; c1 += 1)\n",
       "    a[c0][c1] = a[c0][c1 + 1] + b[c0][c1];\n",
       "  #pragma omp parallel for\n",
       "  for (int c1 = 1; c1 <= 499; c1 += 1) {\n",
       "    c[c0][c1] = a[c0][c1] + d[c0 + 1][c1];\n",
       "    d[c0][c1] = 3 * e[c0][c1];\n",
       "  }\n",
       "}\n",
       "\n",
       "```"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_sched = c3.schedule()\n",
    "builder = isl.ast_build()\n",
    "builder = builder.set_after_each_mark(after_mark_callback)\n",
    "tree: isl.ast_node = builder.node_from(new_sched)\n",
    "printer = isl.printer.to_file_path('/tmp/2.c')\n",
    "printer.set_output_format(isl.format.C)\n",
    "\n",
    "options = isl.ast_print_options.alloc()\n",
    "options = options.set_print_for(print_for_callback)\n",
    "options = options.set_print_user(print_user_callback)\n",
    "tree.print(printer, options)\n",
    "printer.flush()\n",
    "\n",
    "CSource('/tmp/2.c')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ci",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}