问题导读：
1、Scheduler任务中Distributed Plan、Scan Range是什么？
2、Scheduler基本接口有哪些？
3、QuerySchedule这个类如何理解？
4、SimpleScheduler接口如何实现的？
Scheduler的任务
1、相关概念：Distributed Plan
在Frontend中已经把SQL转换成了single node plan，然后又将其切分成了distributed plan。代码见Planner::createPlan和DistributedPlanner::createPlanFragments.
比如左图的single node plan会切成为右图的distributed plan（图片来源自impala官方PPT：Query Compilation in Impala）。在impala-shell中set explain_level=3后用explain可以看到distributed plan。
<ignore_js_op>
上图的Distributed Plan中，一个带颜色的圈是一个Plan Fragment。Plan Fragment间的箭头是Fragment间的数据流动，Plan Fragment内矩形间的箭头是Fragment内各个Plan Node的数据流动。上图其实省略了Distributed Plan中每个非叶子结点里的ExchangeNode，其是用来接收其它Plan Fragment的数据的。一个Plan Fragment会有一个或多个instance，运行在不同impalad上。
2、相关概念：Scan Range
在distributed plan中，每个scan node已经设置好要处理的scan ranges，即有哪些输入文件要处理，每个有哪些block。从Frontend传来的scan range对应一个block，由于一个block有多个replica，因此一个scan range会有多个location。了解scan range的概念非常重要，下面是相关的thrift定义：
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
|
// PlanNodes.thriftstruct TScanRange { // one of these must be set for every TScanRange
1: optional THdfsFileSplit hdfs_file_split
2: optional THBaseKeyRange hbase_key_range
}struct THdfsFileSplit { // File name (not the full path). The path is assumed to be the
// 'location' of the THdfsPartition referenced by partition_id.
1: required string file_name
2: required i64 offset
3: required i64 length
// ID of partition within the THdfsTable associated with this scan node
4: required i64 partition_id
5: required i64 file_length
6: required CatalogObjects.THdfsCompression file_compression
7: required i64 mtime // last modified time
}struct THBaseKeyRange { 1: optional string startKey // inclusive
2: optional string stopKey // exclusive
} |
一个ScanRange要么是HDFS文件上的一部分（用file_name，offset和length等来表示），要么是Hbase一片连续的rowKey（用[startKey, endKey)表示）。
|
01
02
03
04
05
06
07
08
09
10
11
12
13
|
// Planer.thriftstruct TScanRangeLocation { // 对应HDFS上一个block位置，定位到硬盘编号
// Index into TQueryExecRequest.host_list.
1: required i32 host_idx;
2: optional i32 volume_id = -1
3: optional bool is_cached = false // If true, this block is cached on this server
}struct TScanRangeLocations { // 一个ScanRange对应的各个replica的位置列表
1: required PlanNodes.TScanRange scan_range
// non-empty list
2: list<TScanRangeLocation> locations
} |
TScanRangeLocations就记录了Scan Range的位置列表，这个类型在TQueryExecRequest中会被用到。TQueryExecRequest的成员per_node_scan_ranges记录了每个ScanNode要处理的一系列ScanRange，每个ScanRange用TScanRangeLocations来表示。因此per_node_scan_ranges的类型是 map<Types.TPlanNodeId, list<Planner.TScanRangeLocations>>.
TQueryExecRequest是Frontend传给Backend的执行计划，Backend会生成 fragment 的执行计划发送给其它 impalad 去执行，这其中就包含了Scheduler的工作。impalad之间通信的数据结构定义在ImpalaInternalService.thrift中，关于ScanRange使用的是TScanRangeParams，此时已经确定了Scan任务要放在哪台机器上去执行（就是接收信息的impalad），因此不再需要location信息里的host_idx。
|
1
2
3
4
5
6
7
8
|
// ImpalaInternalService.thrift// A scan range plus the parameters needed to execute that scan.struct TScanRangeParams { 1: required PlanNodes.TScanRange scan_range
2: optional i32 volume_id = -1
3: optional bool is_cached = false
4: optional bool is_remote
} |
3、Scheduler的任务
我们知道HDFS是有多备份的，一个block经常会有多于一个复本，因此在HDFS上的位置也会有多于一个。那么读取的时候到底在哪个复本上执行，这就是Scheduler要做的事情。另外其它的上层plan fragment也需要确定在哪些机器上执行。
代码注释如是说：
|
1
|
Given a list of resources and locations returns a list of hosts on which to execute plan fragments requiring those resources. |
这其实很像MapReduce里对mapper和reducer的调度。
Scheduler基本接口
|
1
|
virtual Status Init() = 0;
|
该接口初始化本Scheduler，返回时表示已获取了做调试决策所需要的所有资源。
定义BackendList类型表示一列Backend描述符。
|
1
|
typedef std::vector<TBackendDescriptor> BackendList; |
|
1
|
virtual Status GetBackends(const std::vector<TNetworkAddress>& data_locations, BackendList* backends) = 0;
|
该接口输入是一组 host/port 二元组表示的data location，输出是一组运行在那些机器上或附近（比如同机架）的Backend列表。
|
1
|
virtual Status GetBackend(const TNetworkAddress& data_location, TBackendDescriptor* backend) = 0;
|
该接口输入是一个 host/port 二元组表示的 data location，输出是一个运行在该机器上或附近的Backend。
|
1
|
virtual bool HasLocalBackend(const TNetworkAddress& data_location) = 0;
|
返回是否有Backend运行在资源所在的机器上。
|
1
|
virtual void GetAllKnownBackends(BackendList* backends) = 0;
|
返回该scheduler知道的所有Backend
|
1
|
virtual Status Schedule(Coordinator* coord, QuerySchedule* schedule) = 0;
|
该接口最主要的输入是QueryScheduler::request()，即一个TQueryExecRequest对象，描述了query的执行计划。参数里的Coordinator只提供一些全局的信息，比如user name等。TQueryExecRequest的per_node_scan_ranges记录了要处理的scan ranges。该接口将这些scan range分配到对应的机器上去，分配信息（即调度信息）记录在QuerySchedule的fragment_exec_params_中。
如果开启了资源管理，即impala运行在Yarn上时，该接口也会向resource manager（通过Llama）申请资源来执行query。该接口在资源申请被同意或拒绝前是阻塞的。
|
1
|
virtual Status Release(QuerySchedule* schedule) = 0;
|
释放资源
下面的几个接口主要是Impala on Yarn要用到的回调函数，字面意思比较直观
|
1
2
3
|
virtual void HandlePreemptedReservation(const TUniqueId& reservation_id) = 0;
virtual void HandlePreemptedResource(const TUniqueId& client_resource_id) = 0;
virtual void HandleLostResource(const TUniqueId& client_resource_id) = 0;
|
QuerySchedule
在读懂SimpleScheduler的代码前需要先过一下QuerySchedule这个类，SimpleScheduler的任务是把QueryScheduler对象补充完整。
一个QueryScheduler包含了coordinator生成fragment执行请求从而启动query执行所需要的所有信息。Coordinator根据QueryScheduler生成FragmentExecParams，发送给各个impalad去执行fragment instance。
如果开启了资源管理（即Impala on Yarn），则QueryScheduler中还会包含需要申请的资源和已经获得的资源。
query-schedule.h中首先定义了两个类型：
|
1
2
|
typedef std::map<TPlanNodeId, std::vector<TScanRangeParams> > PerNodeScanRanges;typedef boost::unordered_map<TNetworkAddress, PerNodeScanRanges> FragmentScanRangeAssignment; |
PerNodeScanRanges是ScanNode到ScanRange列表的映射，FragmentScanRangeAssignment是impalad到PerNodeScanRanges的映射。
每个Scan Node可能有多个scan range，分配到不同impalad上去执行。因此这里有个impalad到其任务的映射，即它要处理哪些scan node的哪些scan range。
QuerySchedule有几个重要的成员变量：
<ignore_js_op>
其中plan_node_to_fragment_idx_和plan_node_to_plan_node_idx_是在进入SimpleScheduler::Schedule前就生成好的了。Schedule函数最主要的任务是填充fragment_exec_params_和unique_hosts等成员变量。fragment_exec_params是一个FragmentExecParams数组，记录了每个fragment的执行请求，用来发送给其它impalad去运行fragment instance。FragmentExecParams的定义如下：
|
1
2
3
4
5
6
7
8
|
struct FragmentExecParams { std::vector<TNetworkAddress> hosts; // 将在哪些backend上执行，每个backend执行一个instance
std::vector<TUniqueId> instance_ids; // 各个instance的id
std::vector<TPlanFragmentDestination> destinations; // 所有输出目标，TPlanFragmentDestination是目标fragment的各个instance id及其所运行在的server
std::map<PlanNodeId, int> per_exch_num_senders; // 本fragment里各个exchange node的输入instance总数
FragmentScanRangeAssignment scan_range_assignment; // scan range的调度信息，比如hdfs上replica的选择信息
int sender_id_base; // 本fragment作为一个sender时的base id
}; |
这里的sender_id_base需要再解释一下。除了根fragment以外的每个fragment都有另一个fragment作为输出目标，除了叶子fragment外的所有fragment都有若干输入fragment。因此除了根fragment以外的每个fragment都需要扮演sender的角色，除了叶子fragment外的所有fragment也都要扮演receiver的角色。每一个fragment都有一个或多个instance，receiver会为自己的各个sender (instance)分配id用来区分，id从0开始。为了方便，我们给同一个fragment的不同instance分配连续的id，这样只需要记住起始id和该fragment的instance数目就够了。成员变量sender_id_base记录的就是自己作为sender时，由receiver分配的起始id。
SimpleScheduler接口实现
目前Impala on Yarn还不是很流行，我们可以先跳过跟resource management相关的代码，这样看起来会更容易些。最主要的逻辑还是Schedule接口：
|
1
|
Status SimpleScheduler::Schedule(Coordinator* coord, QuerySchedule* schedule) |
主要做三件事情：
- ComputeScanRangeAssignment(schedule->request(), schedule));
填充各个FragmentExecParams对象中的scan_range_assignment
- ComputeFragmentHosts(schedule->request(), schedule);
填充各个FragmentExecParams对象中的hosts，即计算每个fragment instance在哪个impalad上执行
- ComputeFragmentExecParams(schedule->request(), schedule);
填充各个FragmentExecParams对象中剩下的内容，即destinations、per_exch_num_senders和sender_id_base
调用完这三个函数后，QuerySchedule的fragment_exec_params_就被填充完整了。下面分别介绍这三部分。
ComputeScanRangeAssignment
|
1
|
Status SimpleScheduler::ComputeScanRangeAssignment(const TQueryExecRequest& exec_request, QuerySchedule* schedule)
|
正如函数名所述，该函数主要处理scan range的分配，即每个scan range的data host的选择。这里主要是hdfs上的scan range需要处理，因为每个block有多个replica，有多个DataNode可供选择，而hbase上的region只归一个RegionServer（即这里的data host）管理。
exec_request.per_node_scan_ranges是一个map，记录了每个scan node对应的所有scan ranges。该函数的主体是一个for循环，每次处理一个scan node。
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
for (entry = exec_request.per_node_scan_ranges.begin();
entry != exec_request.per_node_scan_ranges.end(); ++entry) {
const TPlanNodeId node_id = entry->first; // 获取该scan node在整个执行计划树中的id
int fragment_idx = schedule->GetFragmentIdx(node_id); // 获取该scan node所在的fragment的下标。
const TPlanFragment& fragment = exec_request.fragments[fragment_idx]; // 获取该scan node所在的fragment引用
bool exec_at_coord = (fragment.partition.type == TPartitionType::UNPARTITIONED); // 该scan node是否在Coordinator处执行
// 获取该scan node的引用。schedule->GetNodeIdx返回的是node在其fragment的执行计划树中的下标。
const TPlanNode& node = fragment.plan.nodes[schedule->GetNodeIdx(node_id)];
DCHECK_EQ(node.node_id, node_id);
// 下面的TReplicaPreference类型是复本选择时的默认策略，是个枚举类型，总共有5种：
// CACHE_LOCAL, CACHE_RACK, DISK_LOCAL, DISK_RACK, REMOTE
const TReplicaPreference::type* node_replica_preference = node.__isset.hdfs_scan_node
&& node.hdfs_scan_node.__isset.replica_preference
? &node.hdfs_scan_node.replica_preference : NULL; // 如果scan node里有设置，就拿这个默认配置，否则记为NULL
// random_replica表示当有几个复本各方面条件都一样时，是否随机选择。否则直接选第一个复本。
bool node_random_replica = node.__isset.hdfs_scan_node &&
node.hdfs_scan_node.__isset.random_replica &&
node.hdfs_scan_node.random_replica;
// FragmentScanRangeAssignment类型记录一个fragment里所有scan range的分配，即选择哪些复本。实际是一个map：
// typedef boost::unordered_map<TNetworkAddress, PerNodeScanRanges> FragmentScanRangeAssignment;
// 上面的TNetworkAddress是impalad的地址（用host+port表示），PerNodeScanRanges也是一个map，记录每个scan node的所有scan range：
// typedef std::map<TPlanNodeId, std::vector<TScanRangeParams> > PerNodeScanRanges;
// 下面这行获取该fragment的assignment引用，所有fragment执行信息（即FragmentExecParams）在schedule->exec_params()数组中
FragmentScanRangeAssignment* assignment =
&(*schedule->exec_params())[fragment_idx].scan_range_assignment;
// 根据以上获取的对象进行实质的分配，并把结果写入assignment对象中
RETURN_IF_ERROR(ComputeScanRangeAssignment(
node_id, node_replica_preference, node_random_replica, entry->second,
exec_request.host_list, exec_at_coord, schedule->query_options(), assignment));
schedule->AddScanRanges(entry->second.size()); // 更新schedule对象中的scan range计数
} |
ComputeScanRangeAssignment
|
1
2
3
4
5
|
Status SimpleScheduler::ComputeScanRangeAssignment( PlanNodeId node_id, const TReplicaPreference::type* node_replica_preference,
bool node_random_replica, const vector<TScanRangeLocations>& locations,
const vector<TNetworkAddress>& host_list, bool exec_at_coord,
const TQueryOptions& query_options, FragmentScanRangeAssignment* assignment)
|
逐个过下参数：
- node_id：要处理的scan node的id
- node_replica_preference：replica的默认选择策略，是个枚举类例，取值可以是CACHE_LOCAL、DISK_LOCAL等，没有的话就是NULL
- node_random_replica：对于条件相同的replica，是否随机选择。否的话就直接选第一个。
- locations：各个scan range（也即block）的location列表（replica列表）
- host_list：复本所在的host列表，即DataNode列表
- exec_at_coord：该scan node是否在Coordinator处运行
- query_options：各种查询参数，详见TQueryOption定义
- assignment：调度结果存储在该对象中
函数的主体是两层的for循环，第一层为每个scan range，第二层为该scan range的各个location，也即replica。
代码中比较难懂的局部变量是base_distance，所谓的distance不过是CACHE_LOCAL, CACHE_RACK, DISK_LOCAL, DISK_RACK, REMOTE中的一种，表示impalad和它要读取的数据的距离。base_distance是一个基准线，就是说距离比这个还小（优）的我们就当成一样的来对待了。
另一个局部变量random_non_cached_tiebreak意义与参数node_random_replica相同，就是条件都一样的replica中是随机挑一个还是直接选第一个。
除去profile和打log的代码，函数主体的伪代码如下：
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
assigned_bytes_per_host是一个map，记录各个DataNode被分配的数据量，即有多少数据要从该DataNode读取foreach ScanRange in ScanNode //min_distance 记录replica到impalad的最小距离，初始值为REMOTE
// min_assigned_bytes，该变量帮助我们找到被分配任务最少的DataNode。每个replica从属于一个DataNode，如果有几个replica的distance相等，则比较它们所在DataNode所要读取的数据量。
// 这几个局部变量记录最终的选择结果：data_host、volume_id、is_cached、remote_read
//num_equivalent_replicas记录各方面条件都相同的replica数目
foreach Location in ScanRange
// replica_host 是replica所在的DataNode
//计算memory_distance，如果优于base_distance则折合成base_distance
//assigned_bytes 是replica所在DataNode当前被分配的数据量
//bool变量found_new_replica表示是否选择该replica
if (memory_distance < min_distance) {
min_distance = memory_distance;
num_equivalent_replicas = 1;
found_new_replica = true;
} else if (memory_distance == min_distance) {
bool cached_replica = memory_distance == TReplicaPreference::CACHE_LOCAL;
if (assigned_bytes < min_assigned_bytes) {
num_equivalent_replicas = 1;
found_new_replica = true;
} else if (assigned_bytes == min_assigned_bytes &&
(random_non_cached_tiebreak || cached_replica)) {
// 如果之前已经有k个相等的replica，则以1/(k+1)的概率决定是否采用本replica.
// 这样前面的replica被选中的概率各是 1/k * k/(k+1) = 1/(k+1)，从而实现随机挑选
++num_equivalent_replicas;
const int r = rand(); // make debugging easier.
found_new_replica = (r % num_equivalent_replicas == 0);
}
}
if (found_new_replica) { // 如果采用当前replica，则更新一系列值
min_assigned_bytes = assigned_bytes;
data_host = &replica_host;
volume_id = location.volume_id;
is_cached = location.is_cached;
remote_read = min_distance == TReplicaPreference::REMOTE;
}
} // end of each location (replica)
更新remote_bytes、remote_hosts、local_bytes、cached_bytes、assigned_bytes_per_host
为data_host找一个backend host(即exec_hostport)，如果该DataNode所在机器上就有impalad，则选择该impalad，
否则以round robin（轮循）的方式在impalad列表中挑一个。另外，如果函数参数中exec_at_coord为true，
则该scan node只在Coordinator所在impalad上执行，也就是当前机器。
///////////// 把结果存入assignment中 /////////////
PerNodeScanRanges* scan_ranges =
FindOrInsert(assignment, exec_hostport, PerNodeScanRanges());
vector<TScanRangeParams>* scan_range_params_list =
FindOrInsert(scan_ranges, node_id, vector<TScanRangeParams>());
// add scan range
TScanRangeParams scan_range_params;
scan_range_params.scan_range = scan_range_locations.scan_range;
// Explicitly set the optional fields.
scan_range_params.__set_volume_id(volume_id);
scan_range_params.__set_is_cached(is_cached);
scan_range_params.__set_is_remote(remote_read);
scan_range_params_list->push_back(scan_range_params);
} // end of each scan range
|
回顾一下，assignment是一个映射，记录每个impalad的scan任务，存在一个PerNodeScanRanges对象中。每个PerNodeScanRanges对象也是一个映射，记录一个scan node在该impalad要读的数据，用vector表示。每个TScanRangeParams表示一个读任务，如果is_remote为false，则在所在impalad机器上的DataNode处读取，此时is_cached表示数据是否已缓存在该impalad中，volume_id记录了数据在哪块磁盘。如果is_remote为true，则根据PlanNodes.TScanRange去获取数据源来读取，使用hdfs或hbase的api。
ComputeFragmentHosts
|
1
2
|
void SimpleScheduler::ComputeFragmentHosts(const TQueryExecRequest& exec_request,
QuerySchedule* schedule) {
|
上一个Compute函数进行了replica的选取，接下来要给出每个fragment instance在哪个impalad上去执行。
这个函数的输出是schedule->exec_params()中各个FragmentExecParams的hosts部分，最后还会更新下schedule里的unique_hosts_，即整个query涉及到的其它impalad（除去本机）
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
vector<FragmentExecParams>* fragment_exec_params = schedule->exec_params(); // 拿出要修改的对象列表
TNetworkAddress coord = MakeNetworkAddress(FLAGS_hostname, FLAGS_be_port); // Coordinator地址即是本进程地址
DCHECK_EQ(fragment_exec_params->size(), exec_request.fragments.size());
vector<TPlanNodeType::type> scan_node_types; // 目前的scan node总共有三种类型
scan_node_types.push_back(TPlanNodeType::HDFS_SCAN_NODE);
scan_node_types.push_back(TPlanNodeType::HBASE_SCAN_NODE);
scan_node_types.push_back(TPlanNodeType::DATA_SOURCE_NODE);
// 从后往前处理各个fragment，因为前面的fragment依赖于后面的输出，可能会调度到后面fragment同样的hosts上去，
// 因此底层的fragment要先处理。
for (int i = exec_request.fragments.size() - 1; i >= 0; --i) {
const TPlanFragment& fragment = exec_request.fragments[i];
[/i]FragmentExecParams& params = (*fragment_exec_params);
if (fragment.partition.type == TPartitionType::UNPARTITIONED) {
// all single-node fragments run on the coordinator host
params.hosts.push_back(coord);
continue;
}
// UnionNode会通过ExchangeNode接收其它fragment的输入，也会接收所在fragment的scan结果。
// 包含UnionNode的fragment不仅会被调度到scan range选择的replica所在机器上，也会被调度到所有输入fragment的instance所在的机器上。
// （使得以partitioned join或grouping aggregate为子结点的UnionNode所运行的机器数目，不小于其子结点的输入数目）
if (ContainsNode(fragment.plan, TPlanNodeType::UNION_NODE)) {
vector<TPlanNodeId> scan_nodes;
FindNodes(fragment.plan, scan_node_types, &scan_nodes); // 取出该fragment的所有scan node
vector<TPlanNodeId> exch_nodes;
FindNodes(fragment.plan,
vector<TPlanNodeType::type>(1, TPlanNodeType::EXCHANGE_NODE),
&exch_nodes); // 取出该fragment的所有exchange node
// 把scan nodes所选择的host加入进来
vector<TNetworkAddress> scan_hosts;
for (int j = 0; j < scan_nodes.size(); ++j) {
GetScanHosts(scan_nodes[j], exec_request, params, &scan_hosts);
}
unordered_set<TNetworkAddress> hosts(scan_hosts.begin(), scan_hosts.end());
// 把input fragments所选择的host加入进来
for (int j = 0; j < exch_nodes.size(); ++j) { // 处理每个exchange node
int input_fragment_idx = FindSenderFragment(exch_nodes[j], i, exec_request); // 找到该exchange node的输入fragment
// 获取该输入fragment的所有hosts，所有输入的fragment应该在处理本fragment之前就已经计算好hosts了
const vector<TNetworkAddress>& input_fragment_hosts =
(*fragment_exec_params)[input_fragment_idx].hosts;
hosts.insert(input_fragment_hosts.begin(), input_fragment_hosts.end());
}
DCHECK(!hosts.empty()) << "no hosts for fragment " << i << " with a UnionNode";
params.hosts.assign(hosts.begin(), hosts.end());
continue;
}
// 查看最左结点是否是scan node. 注意传入的types是scan_node_types
PlanNodeId leftmost_scan_id = FindLeftmostNode(fragment.plan, scan_node_types);
if (leftmost_scan_id == g_ImpalaInternalService_constants.INVALID_PLAN_NODE_ID) {
// 如果最左节点不是scan node，那只能是exchange node。我们把本fragment调度到其对应的输入fragment所在的所有机器上。
// 从而像分布式aggregation这类的fragment可以在本机获得输入fragment的数据
int input_fragment_idx = FindLeftmostInputFragment(i, exec_request);
params.hosts = (*fragment_exec_params)[input_fragment_idx].hosts;
continue;
}
// 找到了最左的scan node，本fragment将在其scan ranges选定的各个replica机器上去执行
GetScanHosts(leftmost_scan_id, exec_request, params, ¶ms.hosts);
}
// 最后再填一下schedule对象中的unique_hosts，即把所有用到的hosts集合的并集
unordered_set<TNetworkAddress> unique_hosts;
BOOST_FOREACH(const FragmentExecParams& exec_params, *fragment_exec_params) {
unique_hosts.insert(exec_params.hosts.begin(), exec_params.hosts.end());
}
schedule->SetUniqueHosts(unique_hosts);
} |
ComputeFragmentExecParams
|
1
2
|
void SimpleScheduler::ComputeFragmentExecParams(const TQueryExecRequest& exec_request,
QuerySchedule* schedule)
|
这是SimpleSchedule::Schedule里调用的最后一个Compute函数，用来把各个FragmentExecParams剩下的内容填补完。
函数主体有两部分：先为各个fragment instance分配id，都有了id之后就可以指明各个instance的输入输出，把它们串成一个有向无环图。
这段代码不难了，有以下两点需要解释：
- 根fragment没有输出，其它的每个fragment都会输出到另一个fragment中的exchange node去，因此需要把目标fragment的各个instance id记录下来，也就是记录本fragment要有几个sender来发送数据，各发到哪些instance去。另外，每个exchange node也要知道有多少个instance会给自己发数据，即sender数目。
- 每个instance的id是一个128位整数（由两个64位整数表示，类型为TUniqueId），其中的高64位与query id的高64位一样，低64位是query id的低64位加上其是第几个instance。
总结
读懂SimpleScheduler的代码对后续阅读Impala更底层的代码很有帮助。在这里可以弄明白很多基本概念，如Plan Fragment Instance、Scan Range、Exchange Node等。
SimpleScheduler的调度策略很直接，把包含Scan Node的Plan Fragment Instance优先调度到数据所在的机器上去运行，同时会考虑均摊对HDFS DataNode的负载。如果数据所在机器上没有impalad，则用round robin的方式选一个远程的impalad。另外上层的Plan Fragment会尽量在其依赖的Plan Fragment所在机器上去运行。