810 /* Fill up the groups array with singleton groups, i.e., one group
819 	struct gpu_array_ref_group **groups, struct gpu_group_data *data)  in populate_array_references()  argument
857 		groups[n++] = group;  in populate_array_references()
898 /* Combine the given two groups into a single group, containing
899  * the references of both groups.
936 /* Combine the given two groups into a single group and free
937  * the original two groups.
1039  * compute shared/private tiles for groups involving may writes.
1213 /* If two groups have overlapping access relations (as determined by
1215  * then merge the two groups into one.
1217  * on the merged groups.
1219  * Return the updated number of groups.
1223 	int n, struct gpu_array_ref_group **groups,  in group_writes()  argument
1232 			if (!groups[i]->write && !groups[j]->write)  in group_writes()
1235 			if (!overlap(groups[i], groups[j]))  in group_writes()
1238 			groups[i] = join_groups_and_free(groups[i], groups[j]);  in group_writes()
1240 				groups[j] = groups[n - 1];  in group_writes()
1241 			groups[n - 1] = NULL;  in group_writes()
1244 			if (!groups[i])  in group_writes()
1247 			    compute_group_bounds(kernel, groups[i], data) < 0)  in group_writes()
1255 /* If two groups have overlapping access relations (within the innermost
1256  * loop) and if one of them involves a write, then merge the two groups
1259  * Return the updated number of groups.
1262 	int n, struct gpu_array_ref_group **groups,  in group_overlapping_writes()  argument
1265 	return group_writes(kernel, n, groups, &accesses_overlap, 0, data);  in group_overlapping_writes()
1294 /* If two groups have overlapping access relations (within the outer
1296  * then merge the two groups into one.
1298  * Return the updated number of groups.
1301 	int n, struct gpu_array_ref_group **groups, struct gpu_group_data *data)  in group_depth_overlapping_writes()  argument
1303 	return group_writes(kernel, n, groups, &depth_accesses_overlap, 1,  in group_depth_overlapping_writes()
1330  * for each group that allows for a shared memory tile, merge two groups
1333  * is smaller than the sum of the tile sizes of the individual groups.
1335  * If merging two groups decreases the depth of the tile of
1336  * one or both of the two groups, then we need to check for overlapping
1339  * Return the number of groups after merging.
1344 	struct gpu_array_ref_group **groups, struct gpu_group_data *data)  in group_common_shared_memory_tile()  argument
1350 		if (!groups[i]->shared_tile)  in group_common_shared_memory_tile()
1355 			if (!groups[j]->shared_tile)  in group_common_shared_memory_tile()
1358 			if (!depth_accesses_overlap(groups[i], groups[j]))  in group_common_shared_memory_tile()
1361 			group = join_groups(groups[i], groups[j]);  in group_common_shared_memory_tile()
1368 					groups[i]->shared_tile,  in group_common_shared_memory_tile()
1369 					groups[j]->shared_tile)) {  in group_common_shared_memory_tile()
1374 			if (group->min_depth < groups[i]->min_depth ||  in group_common_shared_memory_tile()
1375 			    group->min_depth < groups[j]->min_depth)  in group_common_shared_memory_tile()
1377 			gpu_array_ref_group_free(groups[i]);  in group_common_shared_memory_tile()
1378 			gpu_array_ref_group_free(groups[j]);  in group_common_shared_memory_tile()
1379 			groups[i] = group;  in group_common_shared_memory_tile()
1381 				groups[j] = groups[n - 1];  in group_common_shared_memory_tile()
1387 		n = group_depth_overlapping_writes(kernel, n, groups, data);  in group_common_shared_memory_tile()
1391 /* Set array->n_group and array->groups to n and groups.
1396 	int n, struct gpu_array_ref_group **groups)  in set_array_groups()  argument
1401 	array->groups = groups;  in set_array_groups()
1404 		groups[i]->nr = i;  in set_array_groups()
1407 /* Combine all groups in "groups" into a single group and return
1408  * the new number of groups (1 or 0 if there were no groups to start with).
1410 static int join_all_groups(int n, struct gpu_array_ref_group **groups)  in join_all_groups()  argument
1415 		groups[0] = join_groups_and_free(groups[0], groups[i]);  in join_all_groups()
1416 		groups[i] = NULL;  in join_all_groups()
1434  * Furthermore, if two groups admit a shared memory tile and if the
1436  * the two groups.
1450 	struct gpu_array_ref_group **groups;  in group_array_references()  local
1452 	groups = isl_calloc_array(ctx, struct gpu_array_ref_group *,  in group_array_references()
1454 	if (!groups)  in group_array_references()
1457 	n = populate_array_references(local, groups, data);  in group_array_references()
1460 		n = join_all_groups(n, groups);  in group_array_references()
1461 		set_array_groups(local, n, groups);  in group_array_references()
1465 	n = group_overlapping_writes(kernel, n, groups, data);  in group_array_references()
1468 		if (compute_group_bounds(kernel, groups[i], data) < 0)  in group_array_references()
1471 	n = group_depth_overlapping_writes(kernel, n, groups, data);  in group_array_references()
1474 					    n, groups, data);  in group_array_references()
1476 	set_array_groups(local, n, groups);  in group_array_references()
1482 		gpu_array_ref_group_free(groups[i]);  in group_array_references()
1490  * If so, mark the array as force_private so that its reference groups will be