├── .arcconfig ├── .arclint ├── .gitattributes ├── .gitignore ├── CMakeLists.txt ├── CREDITS.txt ├── LICENSE.txt ├── README ├── cmake ├── CMakeLists.txt ├── FindISL.cmake ├── PollyConfig.cmake.in └── polly_macros.cmake ├── docs ├── Architecture.rst ├── CMakeLists.txt ├── HowToManuallyUseTheIndividualPiecesOfPolly.rst ├── Performance.rst ├── ReleaseNotes.rst ├── TipsAndTricks.rst ├── UsingPollyWithClang.rst ├── conf.py ├── doxygen.cfg.in ├── experiments │ └── matmul │ │ ├── init_array___%for.cond1.preheader---%for.end19.jscop │ │ ├── init_array___%for.cond1.preheader---%for.end19.jscop.interchanged │ │ ├── init_array___%for.cond1.preheader---%for.end19.jscop.interchanged+tiled │ │ ├── init_array___%for.cond1.preheader---%for.end19.jscop.interchanged+tiled+vector │ │ ├── main___%for.cond1.preheader---%for.end30.jscop │ │ ├── main___%for.cond1.preheader---%for.end30.jscop.interchanged │ │ ├── main___%for.cond1.preheader---%for.end30.jscop.interchanged+tiled │ │ ├── main___%for.cond1.preheader---%for.end30.jscop.interchanged+tiled+vector │ │ ├── matmul.c │ │ ├── matmul.ll │ │ ├── matmul.normalopt.ll │ │ ├── matmul.normalopt.s │ │ ├── matmul.polly.interchanged+tiled+vector+openmp.ll │ │ ├── matmul.polly.interchanged+tiled+vector+openmp.s │ │ ├── matmul.polly.interchanged+tiled+vector.ll │ │ ├── matmul.polly.interchanged+tiled+vector.s │ │ ├── matmul.polly.interchanged+tiled.ll │ │ ├── matmul.polly.interchanged+tiled.s │ │ ├── matmul.polly.interchanged.ll │ │ ├── matmul.polly.interchanged.s │ │ ├── matmul.preopt.ll │ │ ├── runall.sh │ │ ├── scops.init_array.dot │ │ ├── scops.init_array.dot.png │ │ ├── scops.main.dot │ │ ├── scops.main.dot.png │ │ ├── scops.print_array.dot │ │ ├── scops.print_array.dot.png │ │ ├── scopsonly.init_array.dot │ │ ├── scopsonly.init_array.dot.png │ │ ├── scopsonly.main.dot │ │ ├── scopsonly.main.dot.png │ │ ├── scopsonly.print_array.dot │ │ └── scopsonly.print_array.dot.png ├── images │ ├── GEMM_double.png │ ├── LLVM-Passes-all.pdf │ ├── LLVM-Passes-all.png │ ├── LLVM-Passes-early.pdf │ ├── LLVM-Passes-early.png │ ├── LLVM-Passes-late.pdf │ ├── LLVM-Passes-late.png │ ├── LLVM-Passes-only.pdf │ ├── LLVM-Passes-only.png │ ├── LLVM-Passes.xml │ └── architecture.png └── index.rst ├── include └── polly │ ├── Canonicalization.h │ ├── CodeGen │ ├── BlockGenerators.h │ ├── CodeGeneration.h │ ├── CodegenCleanup.h │ ├── IRBuilder.h │ ├── IslAst.h │ ├── IslExprBuilder.h │ ├── IslNodeBuilder.h │ ├── LoopGenerators.h │ ├── LoopGeneratorsGOMP.h │ ├── LoopGeneratorsKMP.h │ ├── PPCGCodeGeneration.h │ ├── PerfMonitor.h │ ├── RuntimeDebugBuilder.h │ └── Utils.h │ ├── CodePreparation.h │ ├── Config │ └── config.h.cmake │ ├── DeLICM.h │ ├── DependenceInfo.h │ ├── FlattenAlgo.h │ ├── FlattenSchedule.h │ ├── ForwardOpTree.h │ ├── JSONExporter.h │ ├── LinkAllPasses.h │ ├── Options.h │ ├── PolyhedralInfo.h │ ├── PruneUnprofitable.h │ ├── RegisterPasses.h │ ├── ScheduleOptimizer.h │ ├── ScheduleTreeTransform.h │ ├── ScopBuilder.h │ ├── ScopDetection.h │ ├── ScopDetectionDiagnostic.h │ ├── ScopInfo.h │ ├── ScopPass.h │ ├── Simplify.h │ ├── Support │ ├── DumpModulePass.h │ ├── GICHelper.h │ ├── ISLOStream.h │ ├── ISLOperators.h │ ├── ISLTools.h │ ├── LinkGPURuntime.h │ ├── SCEVAffinator.h │ ├── SCEVValidator.h │ ├── ScopHelper.h │ ├── ScopLocation.h │ └── VirtualInstruction.h │ └── ZoneAlgo.h ├── lib ├── Analysis │ ├── DependenceInfo.cpp │ ├── PolyhedralInfo.cpp │ ├── PruneUnprofitable.cpp │ ├── ScopBuilder.cpp │ ├── ScopDetection.cpp │ ├── ScopDetectionDiagnostic.cpp │ ├── ScopGraphPrinter.cpp │ ├── ScopInfo.cpp │ └── ScopPass.cpp ├── CMakeLists.txt ├── CodeGen │ ├── BlockGenerators.cpp │ ├── CodeGeneration.cpp │ ├── CodegenCleanup.cpp │ ├── IRBuilder.cpp │ ├── IslAst.cpp │ ├── IslExprBuilder.cpp │ ├── IslNodeBuilder.cpp │ ├── LoopGenerators.cpp │ ├── LoopGeneratorsGOMP.cpp │ ├── LoopGeneratorsKMP.cpp │ ├── ManagedMemoryRewrite.cpp │ ├── PPCGCodeGeneration.cpp │ ├── PerfMonitor.cpp │ ├── RuntimeDebugBuilder.cpp │ └── Utils.cpp ├── Exchange │ └── JSONExporter.cpp ├── External │ ├── CMakeLists.txt │ ├── README.txt │ ├── isl │ │ ├── AUTHORS │ │ ├── ChangeLog │ │ ├── GIT_HEAD_ID │ │ ├── LICENSE │ │ ├── Makefile.am │ │ ├── Makefile.in │ │ ├── README │ │ ├── aclocal.m4 │ │ ├── all.c │ │ ├── all.h │ │ ├── basis_reduction_tab.c │ │ ├── basis_reduction_templ.c │ │ ├── bound.c │ │ ├── bound_test.sh.in │ │ ├── bset_from_bmap.c │ │ ├── bset_to_bmap.c │ │ ├── cat.c │ │ ├── closure.c │ │ ├── codegen.c │ │ ├── codegen_test.sh.in │ │ ├── compile │ │ ├── config.guess │ │ ├── config.sub │ │ ├── configure │ │ ├── configure.ac │ │ ├── cpp │ │ │ ├── cpp-checked-conversion.h.bot │ │ │ ├── cpp-checked-conversion.h.top │ │ │ ├── cpp-checked.h.bot │ │ │ ├── cpp-checked.h.pre │ │ │ ├── cpp-checked.h.top │ │ │ ├── cpp.h.bot │ │ │ ├── cpp.h.pre │ │ │ └── cpp.h.top │ │ ├── depcomp │ │ ├── doc │ │ │ ├── CodingStyle │ │ │ ├── Makefile.am │ │ │ ├── Makefile.in │ │ │ ├── SubmittingPatches │ │ │ ├── implementation.tex │ │ │ ├── isl.bib │ │ │ ├── manual.tex │ │ │ ├── mypod2latex │ │ │ ├── reading.tex │ │ │ └── user.pod │ │ ├── extract_key.c │ │ ├── flow.c │ │ ├── flow_cmp.c │ │ ├── flow_test.sh.in │ │ ├── imath │ │ │ ├── gmp_compat.c │ │ │ ├── gmp_compat.h │ │ │ ├── imath.c │ │ │ ├── imath.h │ │ │ ├── imrat.c │ │ │ └── imrat.h │ │ ├── imath_wrap │ │ │ ├── gmp_compat.c │ │ │ ├── gmp_compat.h │ │ │ ├── imath.c │ │ │ ├── imath.h │ │ │ ├── imrat.c │ │ │ ├── imrat.h │ │ │ └── wrap.h │ │ ├── include │ │ │ └── isl │ │ │ │ ├── aff.h │ │ │ │ ├── aff_type.h │ │ │ │ ├── arg.h │ │ │ │ ├── ast.h │ │ │ │ ├── ast_build.h │ │ │ │ ├── ast_type.h │ │ │ │ ├── constraint.h │ │ │ │ ├── cpp-checked-conversion.h │ │ │ │ ├── cpp-checked.h │ │ │ │ ├── cpp.h │ │ │ │ ├── ctx.h │ │ │ │ ├── fixed_box.h │ │ │ │ ├── flow.h │ │ │ │ ├── hash.h │ │ │ │ ├── hmap.h │ │ │ │ ├── hmap_templ.c │ │ │ │ ├── id.h │ │ │ │ ├── id_to_ast_expr.h │ │ │ │ ├── id_to_id.h │ │ │ │ ├── id_to_pw_aff.h │ │ │ │ ├── id_type.h │ │ │ │ ├── ilp.h │ │ │ │ ├── isl-noexceptions.h │ │ │ │ ├── list.h │ │ │ │ ├── local_space.h │ │ │ │ ├── lp.h │ │ │ │ ├── map.h │ │ │ │ ├── map_to_basic_set.h │ │ │ │ ├── map_type.h │ │ │ │ ├── mat.h │ │ │ │ ├── maybe.h │ │ │ │ ├── maybe_ast_expr.h │ │ │ │ ├── maybe_basic_set.h │ │ │ │ ├── maybe_id.h │ │ │ │ ├── maybe_pw_aff.h │ │ │ │ ├── maybe_templ.h │ │ │ │ ├── multi.h │ │ │ │ ├── obj.h │ │ │ │ ├── options.h │ │ │ │ ├── point.h │ │ │ │ ├── polynomial.h │ │ │ │ ├── polynomial_type.h │ │ │ │ ├── printer.h │ │ │ │ ├── printer_type.h │ │ │ │ ├── schedule.h │ │ │ │ ├── schedule_node.h │ │ │ │ ├── schedule_type.h │ │ │ │ ├── set.h │ │ │ │ ├── set_type.h │ │ │ │ ├── space.h │ │ │ │ ├── space_type.h │ │ │ │ ├── stream.h │ │ │ │ ├── stride_info.h │ │ │ │ ├── union_map.h │ │ │ │ ├── union_map_type.h │ │ │ │ ├── union_set.h │ │ │ │ ├── union_set_type.h │ │ │ │ ├── val.h │ │ │ │ ├── val_gmp.h │ │ │ │ ├── val_type.h │ │ │ │ ├── vec.h │ │ │ │ ├── version.h │ │ │ │ └── vertices.h │ │ ├── install-sh │ │ ├── interface │ │ │ ├── Makefile.am │ │ │ ├── Makefile.in │ │ │ ├── cpp.cc │ │ │ ├── cpp.h │ │ │ ├── cpp_conversion.cc │ │ │ ├── cpp_conversion.h │ │ │ ├── extract_interface.cc │ │ │ ├── extract_interface.h │ │ │ ├── generator.cc │ │ │ ├── generator.h │ │ │ ├── isl.py │ │ │ ├── python.cc │ │ │ └── python.h │ │ ├── isl_aff.c │ │ ├── isl_aff_map.c │ │ ├── isl_aff_private.h │ │ ├── isl_affine_hull.c │ │ ├── isl_arg.c │ │ ├── isl_ast.c │ │ ├── isl_ast_build.c │ │ ├── isl_ast_build_expr.c │ │ ├── isl_ast_build_expr.h │ │ ├── isl_ast_build_private.h │ │ ├── isl_ast_codegen.c │ │ ├── isl_ast_graft.c │ │ ├── isl_ast_graft_private.h │ │ ├── isl_ast_private.h │ │ ├── isl_basis_reduction.h │ │ ├── isl_bernstein.c │ │ ├── isl_bernstein.h │ │ ├── isl_blk.c │ │ ├── isl_blk.h │ │ ├── isl_bound.c │ │ ├── isl_bound.h │ │ ├── isl_box.c │ │ ├── isl_coalesce.c │ │ ├── isl_config.h.in │ │ ├── isl_config_post.h │ │ ├── isl_constraint.c │ │ ├── isl_constraint_private.h │ │ ├── isl_convex_hull.c │ │ ├── isl_ctx.c │ │ ├── isl_ctx_private.h │ │ ├── isl_deprecated.c │ │ ├── isl_dim_map.c │ │ ├── isl_dim_map.h │ │ ├── isl_equalities.c │ │ ├── isl_equalities.h │ │ ├── isl_factorization.c │ │ ├── isl_factorization.h │ │ ├── isl_farkas.c │ │ ├── isl_ffs.c │ │ ├── isl_flow.c │ │ ├── isl_fold.c │ │ ├── isl_gmp.c │ │ ├── isl_hash.c │ │ ├── isl_hash_private.h │ │ ├── isl_id.c │ │ ├── isl_id_private.h │ │ ├── isl_id_to_ast_expr.c │ │ ├── isl_id_to_id.c │ │ ├── isl_id_to_pw_aff.c │ │ ├── isl_ilp.c │ │ ├── isl_ilp_private.h │ │ ├── isl_imath.c │ │ ├── isl_imath.h │ │ ├── isl_input.c │ │ ├── isl_int.h │ │ ├── isl_int_gmp.h │ │ ├── isl_int_imath.h │ │ ├── isl_int_sioimath.c │ │ ├── isl_int_sioimath.h │ │ ├── isl_list_templ.c │ │ ├── isl_list_templ.h │ │ ├── isl_local.c │ │ ├── isl_local.h │ │ ├── isl_local_space.c │ │ ├── isl_local_space_private.h │ │ ├── isl_lp.c │ │ ├── isl_lp_private.h │ │ ├── isl_map.c │ │ ├── isl_map_lexopt_templ.c │ │ ├── isl_map_list.c │ │ ├── isl_map_private.h │ │ ├── isl_map_simplify.c │ │ ├── isl_map_subtract.c │ │ ├── isl_map_to_basic_set.c │ │ ├── isl_mat.c │ │ ├── isl_mat_private.h │ │ ├── isl_maybe_map.h │ │ ├── isl_morph.c │ │ ├── isl_morph.h │ │ ├── isl_multi_align_set.c │ │ ├── isl_multi_align_templ.c │ │ ├── isl_multi_align_union_set.c │ │ ├── isl_multi_apply_set.c │ │ ├── isl_multi_apply_templ.c │ │ ├── isl_multi_apply_union_set.c │ │ ├── isl_multi_cmp.c │ │ ├── isl_multi_coalesce.c │ │ ├── isl_multi_dims.c │ │ ├── isl_multi_explicit_domain.c │ │ ├── isl_multi_floor.c │ │ ├── isl_multi_gist.c │ │ ├── isl_multi_hash.c │ │ ├── isl_multi_intersect.c │ │ ├── isl_multi_macro.h │ │ ├── isl_multi_no_explicit_domain.c │ │ ├── isl_multi_pw_aff_explicit_domain.c │ │ ├── isl_multi_templ.c │ │ ├── isl_multi_templ.h │ │ ├── isl_multi_union_pw_aff_explicit_domain.c │ │ ├── isl_obj.c │ │ ├── isl_options.c │ │ ├── isl_options_private.h │ │ ├── isl_output.c │ │ ├── isl_output_private.h │ │ ├── isl_point.c │ │ ├── isl_point_private.h │ │ ├── isl_polynomial.c │ │ ├── isl_polynomial_private.h │ │ ├── isl_power_templ.c │ │ ├── isl_printer.c │ │ ├── isl_printer_private.h │ │ ├── isl_pw_eval.c │ │ ├── isl_pw_hash.c │ │ ├── isl_pw_macro.h │ │ ├── isl_pw_templ.c │ │ ├── isl_pw_templ.h │ │ ├── isl_pw_union_opt.c │ │ ├── isl_range.c │ │ ├── isl_range.h │ │ ├── isl_reordering.c │ │ ├── isl_reordering.h │ │ ├── isl_sample.c │ │ ├── isl_sample.h │ │ ├── isl_scan.c │ │ ├── isl_scan.h │ │ ├── isl_schedule.c │ │ ├── isl_schedule_band.c │ │ ├── isl_schedule_band.h │ │ ├── isl_schedule_constraints.c │ │ ├── isl_schedule_constraints.h │ │ ├── isl_schedule_node.c │ │ ├── isl_schedule_node_private.h │ │ ├── isl_schedule_private.h │ │ ├── isl_schedule_read.c │ │ ├── isl_schedule_tree.c │ │ ├── isl_schedule_tree.h │ │ ├── isl_scheduler.c │ │ ├── isl_seq.c │ │ ├── isl_seq.h │ │ ├── isl_set_list.c │ │ ├── isl_sort.c │ │ ├── isl_sort.h │ │ ├── isl_space.c │ │ ├── isl_space_private.h │ │ ├── isl_srcdir.c.in │ │ ├── isl_stream.c │ │ ├── isl_stream_private.h │ │ ├── isl_stride.c │ │ ├── isl_tab.c │ │ ├── isl_tab.h │ │ ├── isl_tab_lexopt_templ.c │ │ ├── isl_tab_pip.c │ │ ├── isl_tarjan.c │ │ ├── isl_tarjan.h │ │ ├── isl_test.c │ │ ├── isl_test_cpp-checked-conversion.cc │ │ ├── isl_test_cpp-checked.cc │ │ ├── isl_test_cpp-generic.cc │ │ ├── isl_test_cpp.cc │ │ ├── isl_test_imath.c │ │ ├── isl_test_int.c │ │ ├── isl_test_python.py │ │ ├── isl_transitive_closure.c │ │ ├── isl_union_eval.c │ │ ├── isl_union_macro.h │ │ ├── isl_union_map.c │ │ ├── isl_union_map_private.h │ │ ├── isl_union_multi.c │ │ ├── isl_union_neg.c │ │ ├── isl_union_set_private.h │ │ ├── isl_union_single.c │ │ ├── isl_union_templ.c │ │ ├── isl_val.c │ │ ├── isl_val_gmp.c │ │ ├── isl_val_imath.c │ │ ├── isl_val_private.h │ │ ├── isl_val_sioimath.c │ │ ├── isl_vec.c │ │ ├── isl_vec_private.h │ │ ├── isl_version.c │ │ ├── isl_vertices.c │ │ ├── isl_vertices_private.h │ │ ├── isl_yaml.h │ │ ├── libisl-gdb.py │ │ ├── ltmain.sh │ │ ├── m4 │ │ │ ├── ax_c___attribute__.m4 │ │ │ ├── ax_cc_maxopt.m4 │ │ │ ├── ax_check_compiler_flags.m4 │ │ │ ├── ax_compiler_vendor.m4 │ │ │ ├── ax_create_pkgconfig_info.m4 │ │ │ ├── ax_create_stdint_h.m4 │ │ │ ├── ax_cxx_compile_stdcxx.m4 │ │ │ ├── ax_cxx_compile_stdcxx_11.m4 │ │ │ ├── ax_detect_clang.m4 │ │ │ ├── ax_detect_git_head.m4 │ │ │ ├── ax_detect_gmp.m4 │ │ │ ├── ax_detect_imath.m4 │ │ │ ├── ax_gcc_archflag.m4 │ │ │ ├── ax_gcc_warn_unused_result.m4 │ │ │ ├── ax_gcc_x86_cpuid.m4 │ │ │ ├── ax_set_warning_flags.m4 │ │ │ ├── ax_submodule.m4 │ │ │ ├── libtool.m4 │ │ │ ├── ltoptions.m4 │ │ │ ├── ltsugar.m4 │ │ │ ├── ltversion.m4 │ │ │ └── lt~obsolete.m4 │ │ ├── missing │ │ ├── mp_get_memory_functions.c │ │ ├── pip.c │ │ ├── pip_test.sh.in │ │ ├── polyhedron_detect_equalities.c │ │ ├── polyhedron_minimize.c │ │ ├── polyhedron_sample.c │ │ ├── polytope_scan.c │ │ ├── print.c │ │ ├── print_templ.c │ │ ├── print_templ_yaml.c │ │ ├── python │ │ │ └── isl.py.top │ │ ├── read_in_string_templ.c │ │ ├── schedule.c │ │ ├── schedule_cmp.c │ │ ├── schedule_test.sh.in │ │ ├── set_from_map.c │ │ ├── set_list_from_map_list_inl.c │ │ ├── set_to_map.c │ │ ├── test-driver │ │ ├── test_inputs │ │ │ ├── affine.polylib │ │ │ ├── affine2.polylib │ │ │ ├── affine3.polylib │ │ │ ├── application.omega │ │ │ ├── application2.omega │ │ │ ├── basicLinear.pwqp │ │ │ ├── basicLinear2.pwqp │ │ │ ├── basicTest.pwqp │ │ │ ├── basicTestParameterPosNeg.pwqp │ │ │ ├── boulet.pip │ │ │ ├── brisebarre.pip │ │ │ ├── cg1.pip │ │ │ ├── codegen │ │ │ │ ├── atomic.c │ │ │ │ ├── atomic.in │ │ │ │ ├── atomic.st │ │ │ │ ├── atomic2.c │ │ │ │ ├── atomic2.in │ │ │ │ ├── atomic3.c │ │ │ │ ├── atomic3.in │ │ │ │ ├── atomic4.c │ │ │ │ ├── atomic4.in │ │ │ │ ├── cholesky.c │ │ │ │ ├── cholesky.st │ │ │ │ ├── cloog │ │ │ │ │ ├── 0D-1.c │ │ │ │ │ ├── 0D-1.st │ │ │ │ │ ├── 0D-2.c │ │ │ │ │ ├── 0D-2.st │ │ │ │ │ ├── 0D-3.c │ │ │ │ │ ├── 0D-3.st │ │ │ │ │ ├── 1point-1.c │ │ │ │ │ ├── 1point-1.st │ │ │ │ │ ├── 1point-2.c │ │ │ │ │ ├── 1point-2.st │ │ │ │ │ ├── 4-param.c │ │ │ │ │ ├── 4-param.st │ │ │ │ │ ├── README │ │ │ │ │ ├── backtrack.c │ │ │ │ │ ├── backtrack.st │ │ │ │ │ ├── basic-bounds-1.c │ │ │ │ │ ├── basic-bounds-1.st │ │ │ │ │ ├── basic-bounds-2.c │ │ │ │ │ ├── basic-bounds-2.st │ │ │ │ │ ├── basic-bounds-3.c │ │ │ │ │ ├── basic-bounds-3.st │ │ │ │ │ ├── basic-bounds-4.c │ │ │ │ │ ├── basic-bounds-4.st │ │ │ │ │ ├── basic-bounds-5.c │ │ │ │ │ ├── basic-bounds-5.st │ │ │ │ │ ├── basic-bounds-6.c │ │ │ │ │ ├── basic-bounds-6.st │ │ │ │ │ ├── block.c │ │ │ │ │ ├── block.st │ │ │ │ │ ├── block2.c │ │ │ │ │ ├── block2.st │ │ │ │ │ ├── block3.c │ │ │ │ │ ├── block3.st │ │ │ │ │ ├── byu98-1-2-3.c │ │ │ │ │ ├── byu98-1-2-3.st │ │ │ │ │ ├── cholesky.c │ │ │ │ │ ├── cholesky.st │ │ │ │ │ ├── cholesky2.c │ │ │ │ │ ├── cholesky2.st │ │ │ │ │ ├── christian.c │ │ │ │ │ ├── christian.st │ │ │ │ │ ├── classen.c │ │ │ │ │ ├── classen.st │ │ │ │ │ ├── classen2.c │ │ │ │ │ ├── classen2.st │ │ │ │ │ ├── constant.c │ │ │ │ │ ├── constant.st │ │ │ │ │ ├── constbound.c │ │ │ │ │ ├── constbound.st │ │ │ │ │ ├── darte.c │ │ │ │ │ ├── darte.st │ │ │ │ │ ├── dealII.c │ │ │ │ │ ├── dealII.st │ │ │ │ │ ├── donotsimp.c │ │ │ │ │ ├── donotsimp.st │ │ │ │ │ ├── dot.c │ │ │ │ │ ├── dot.st │ │ │ │ │ ├── dot2.c │ │ │ │ │ ├── dot2.st │ │ │ │ │ ├── durbin_e_s.c │ │ │ │ │ ├── durbin_e_s.st │ │ │ │ │ ├── emploi.c │ │ │ │ │ ├── emploi.st │ │ │ │ │ ├── equality.c │ │ │ │ │ ├── equality.st │ │ │ │ │ ├── equality2.c │ │ │ │ │ ├── equality2.st │ │ │ │ │ ├── esced.c │ │ │ │ │ ├── esced.st │ │ │ │ │ ├── ex1.c │ │ │ │ │ ├── ex1.st │ │ │ │ │ ├── faber.c │ │ │ │ │ ├── faber.st │ │ │ │ │ ├── forwardsub-1-1-2.c │ │ │ │ │ ├── forwardsub-1-1-2.st │ │ │ │ │ ├── forwardsub-2-1-2-3.c │ │ │ │ │ ├── forwardsub-2-1-2-3.st │ │ │ │ │ ├── forwardsub-3-1-2.c │ │ │ │ │ ├── forwardsub-3-1-2.st │ │ │ │ │ ├── gauss.c │ │ │ │ │ ├── gauss.st │ │ │ │ │ ├── gesced.c │ │ │ │ │ ├── gesced.st │ │ │ │ │ ├── gesced2.c │ │ │ │ │ ├── gesced2.st │ │ │ │ │ ├── gesced3.c │ │ │ │ │ ├── gesced3.st │ │ │ │ │ ├── guide.c │ │ │ │ │ ├── guide.st │ │ │ │ │ ├── iftest.c │ │ │ │ │ ├── iftest.st │ │ │ │ │ ├── iftest2.c │ │ │ │ │ ├── iftest2.st │ │ │ │ │ ├── infinite2.c │ │ │ │ │ ├── infinite2.st │ │ │ │ │ ├── jacobi-shared.c │ │ │ │ │ ├── jacobi-shared.st │ │ │ │ │ ├── largeur.c │ │ │ │ │ ├── largeur.st │ │ │ │ │ ├── levenshtein-1-2-3.c │ │ │ │ │ ├── levenshtein-1-2-3.st │ │ │ │ │ ├── lex.c │ │ │ │ │ ├── lex.st │ │ │ │ │ ├── lineality-1-2.c │ │ │ │ │ ├── lineality-1-2.st │ │ │ │ │ ├── lineality-2-1-2.c │ │ │ │ │ ├── lineality-2-1-2.st │ │ │ │ │ ├── logo.c │ │ │ │ │ ├── logo.st │ │ │ │ │ ├── logopar.c │ │ │ │ │ ├── logopar.st │ │ │ │ │ ├── lu.c │ │ │ │ │ ├── lu.st │ │ │ │ │ ├── lu2.c │ │ │ │ │ ├── lu2.st │ │ │ │ │ ├── lux.c │ │ │ │ │ ├── lux.st │ │ │ │ │ ├── merge.c │ │ │ │ │ ├── merge.st │ │ │ │ │ ├── min-1-1.c │ │ │ │ │ ├── min-1-1.st │ │ │ │ │ ├── min-2-1.c │ │ │ │ │ ├── min-2-1.st │ │ │ │ │ ├── min-3-1.c │ │ │ │ │ ├── min-3-1.st │ │ │ │ │ ├── min-4-1.c │ │ │ │ │ ├── min-4-1.st │ │ │ │ │ ├── mod.c │ │ │ │ │ ├── mod.st │ │ │ │ │ ├── mod2.c │ │ │ │ │ ├── mod2.st │ │ │ │ │ ├── mod3.c │ │ │ │ │ ├── mod3.st │ │ │ │ │ ├── mod4.c │ │ │ │ │ ├── mod4.st │ │ │ │ │ ├── mode.c │ │ │ │ │ ├── mode.st │ │ │ │ │ ├── multi-mm-1.c │ │ │ │ │ ├── multi-mm-1.st │ │ │ │ │ ├── multi-stride.c │ │ │ │ │ ├── multi-stride.st │ │ │ │ │ ├── multi-stride2.c │ │ │ │ │ ├── multi-stride2.st │ │ │ │ │ ├── mxm-shared.c │ │ │ │ │ ├── mxm-shared.st │ │ │ │ │ ├── no_lindep.c │ │ │ │ │ ├── no_lindep.st │ │ │ │ │ ├── nul_basic1.c │ │ │ │ │ ├── nul_basic1.st │ │ │ │ │ ├── nul_basic2.c │ │ │ │ │ ├── nul_basic2.st │ │ │ │ │ ├── nul_complex1.c │ │ │ │ │ ├── nul_complex1.st │ │ │ │ │ ├── nul_lcpc.c │ │ │ │ │ ├── nul_lcpc.st │ │ │ │ │ ├── orc.c │ │ │ │ │ ├── orc.st │ │ │ │ │ ├── otl.c │ │ │ │ │ ├── otl.st │ │ │ │ │ ├── param-split.c │ │ │ │ │ ├── param-split.st │ │ │ │ │ ├── pouchet.c │ │ │ │ │ ├── pouchet.st │ │ │ │ │ ├── rectangle.c │ │ │ │ │ ├── rectangle.st │ │ │ │ │ ├── reservoir-QR.c │ │ │ │ │ ├── reservoir-QR.st │ │ │ │ │ ├── reservoir-bastoul3.c │ │ │ │ │ ├── reservoir-bastoul3.st │ │ │ │ │ ├── reservoir-cholesky2.c │ │ │ │ │ ├── reservoir-cholesky2.st │ │ │ │ │ ├── reservoir-fusion1.c │ │ │ │ │ ├── reservoir-fusion1.st │ │ │ │ │ ├── reservoir-fusion2.c │ │ │ │ │ ├── reservoir-fusion2.st │ │ │ │ │ ├── reservoir-jacobi2.c │ │ │ │ │ ├── reservoir-jacobi2.st │ │ │ │ │ ├── reservoir-jacobi3.c │ │ │ │ │ ├── reservoir-jacobi3.st │ │ │ │ │ ├── reservoir-lim-lam1.c │ │ │ │ │ ├── reservoir-lim-lam1.st │ │ │ │ │ ├── reservoir-lim-lam2.c │ │ │ │ │ ├── reservoir-lim-lam2.st │ │ │ │ │ ├── reservoir-lim-lam3.c │ │ │ │ │ ├── reservoir-lim-lam3.st │ │ │ │ │ ├── reservoir-lim-lam4.c │ │ │ │ │ ├── reservoir-lim-lam4.st │ │ │ │ │ ├── reservoir-lim-lam5.c │ │ │ │ │ ├── reservoir-lim-lam5.st │ │ │ │ │ ├── reservoir-lim-lam6.c │ │ │ │ │ ├── reservoir-lim-lam6.st │ │ │ │ │ ├── reservoir-liu-zhuge1.c │ │ │ │ │ ├── reservoir-liu-zhuge1.st │ │ │ │ │ ├── reservoir-loechner3.c │ │ │ │ │ ├── reservoir-loechner3.st │ │ │ │ │ ├── reservoir-loechner4.c │ │ │ │ │ ├── reservoir-loechner4.st │ │ │ │ │ ├── reservoir-loechner5.c │ │ │ │ │ ├── reservoir-loechner5.st │ │ │ │ │ ├── reservoir-long.c │ │ │ │ │ ├── reservoir-long.st │ │ │ │ │ ├── reservoir-mg-interp.c │ │ │ │ │ ├── reservoir-mg-interp.st │ │ │ │ │ ├── reservoir-mg-interp2.c │ │ │ │ │ ├── reservoir-mg-interp2.st │ │ │ │ │ ├── reservoir-mg-psinv.c │ │ │ │ │ ├── reservoir-mg-psinv.st │ │ │ │ │ ├── reservoir-mg-resid.c │ │ │ │ │ ├── reservoir-mg-resid.st │ │ │ │ │ ├── reservoir-mg-rprj3.c │ │ │ │ │ ├── reservoir-mg-rprj3.st │ │ │ │ │ ├── reservoir-pingali1.c │ │ │ │ │ ├── reservoir-pingali1.st │ │ │ │ │ ├── reservoir-pingali2.c │ │ │ │ │ ├── reservoir-pingali2.st │ │ │ │ │ ├── reservoir-pingali3.c │ │ │ │ │ ├── reservoir-pingali3.st │ │ │ │ │ ├── reservoir-pingali4.c │ │ │ │ │ ├── reservoir-pingali4.st │ │ │ │ │ ├── reservoir-pingali5.c │ │ │ │ │ ├── reservoir-pingali5.st │ │ │ │ │ ├── reservoir-pingali6.c │ │ │ │ │ ├── reservoir-pingali6.st │ │ │ │ │ ├── reservoir-stride.c │ │ │ │ │ ├── reservoir-stride.st │ │ │ │ │ ├── reservoir-stride2.c │ │ │ │ │ ├── reservoir-stride2.st │ │ │ │ │ ├── reservoir-tang-xue1.c │ │ │ │ │ ├── reservoir-tang-xue1.st │ │ │ │ │ ├── reservoir-two.c │ │ │ │ │ ├── reservoir-two.st │ │ │ │ │ ├── singleton.c │ │ │ │ │ ├── singleton.st │ │ │ │ │ ├── sor1d.c │ │ │ │ │ ├── sor1d.st │ │ │ │ │ ├── square+triangle-1-1-2-3.c │ │ │ │ │ ├── square+triangle-1-1-2-3.st │ │ │ │ │ ├── stride.c │ │ │ │ │ ├── stride.st │ │ │ │ │ ├── stride2.c │ │ │ │ │ ├── stride2.st │ │ │ │ │ ├── stride3.c │ │ │ │ │ ├── stride3.st │ │ │ │ │ ├── stride4.c │ │ │ │ │ ├── stride4.st │ │ │ │ │ ├── swim.c │ │ │ │ │ ├── swim.st │ │ │ │ │ ├── test.c │ │ │ │ │ ├── test.st │ │ │ │ │ ├── thomasset.c │ │ │ │ │ ├── thomasset.st │ │ │ │ │ ├── tiling.c │ │ │ │ │ ├── tiling.st │ │ │ │ │ ├── uday_scalars.c │ │ │ │ │ ├── uday_scalars.st │ │ │ │ │ ├── union.c │ │ │ │ │ ├── union.st │ │ │ │ │ ├── unroll.c │ │ │ │ │ ├── unroll.st │ │ │ │ │ ├── unroll2.c │ │ │ │ │ ├── unroll2.st │ │ │ │ │ ├── usvd_e_t.c │ │ │ │ │ ├── usvd_e_t.st │ │ │ │ │ ├── vasilache.c │ │ │ │ │ ├── vasilache.st │ │ │ │ │ ├── vivien.c │ │ │ │ │ ├── vivien.st │ │ │ │ │ ├── vivien2.c │ │ │ │ │ ├── vivien2.st │ │ │ │ │ ├── walters.c │ │ │ │ │ ├── walters.st │ │ │ │ │ ├── walters2.c │ │ │ │ │ ├── walters2.st │ │ │ │ │ ├── walters3.c │ │ │ │ │ ├── walters3.st │ │ │ │ │ ├── wavefront.c │ │ │ │ │ ├── wavefront.st │ │ │ │ │ ├── yosr.c │ │ │ │ │ ├── yosr.st │ │ │ │ │ ├── yosr2.c │ │ │ │ │ ├── yosr2.st │ │ │ │ │ ├── youcef.c │ │ │ │ │ ├── youcef.st │ │ │ │ │ ├── youcefn.c │ │ │ │ │ └── youcefn.st │ │ │ │ ├── component0.c │ │ │ │ ├── component0.st │ │ │ │ ├── component1.c │ │ │ │ ├── component1.st │ │ │ │ ├── component2.c │ │ │ │ ├── component2.st │ │ │ │ ├── component3.c │ │ │ │ ├── component3.st │ │ │ │ ├── component4.c │ │ │ │ ├── component4.st │ │ │ │ ├── component5.c │ │ │ │ ├── component5.st │ │ │ │ ├── component6.c │ │ │ │ ├── component6.st │ │ │ │ ├── component7.c │ │ │ │ ├── component7.st │ │ │ │ ├── correlation.c │ │ │ │ ├── correlation.st │ │ │ │ ├── disjuncts.c │ │ │ │ ├── disjuncts.in │ │ │ │ ├── disjuncts2.c │ │ │ │ ├── disjuncts2.st │ │ │ │ ├── dwt.c │ │ │ │ ├── dwt.in │ │ │ │ ├── empty.c │ │ │ │ ├── empty.in │ │ │ │ ├── filter.c │ │ │ │ ├── filter.st │ │ │ │ ├── gemm.c │ │ │ │ ├── gemm.st │ │ │ │ ├── hoist.c │ │ │ │ ├── hoist.in │ │ │ │ ├── hoist2.c │ │ │ │ ├── hoist2.in │ │ │ │ ├── isolate1.c │ │ │ │ ├── isolate1.st │ │ │ │ ├── isolate2.c │ │ │ │ ├── isolate2.st │ │ │ │ ├── isolate3.c │ │ │ │ ├── isolate3.st │ │ │ │ ├── isolate4.c │ │ │ │ ├── isolate4.st │ │ │ │ ├── isolate5.c │ │ │ │ ├── isolate5.st │ │ │ │ ├── isolate6.c │ │ │ │ ├── isolate6.st │ │ │ │ ├── isolate7.c │ │ │ │ ├── isolate7.st │ │ │ │ ├── jacobi_kernel4.c │ │ │ │ ├── jacobi_kernel4.in │ │ │ │ ├── lu.c │ │ │ │ ├── lu.in │ │ │ │ ├── mod.c │ │ │ │ ├── mod.in │ │ │ │ ├── omega │ │ │ │ │ ├── README │ │ │ │ │ ├── basics-0.c │ │ │ │ │ ├── basics-0.in │ │ │ │ │ ├── basics-1.c │ │ │ │ │ ├── basics-1.in │ │ │ │ │ ├── chosol-0.c │ │ │ │ │ ├── chosol-0.in │ │ │ │ │ ├── chosol-1.c │ │ │ │ │ ├── chosol-1.in │ │ │ │ │ ├── code_gen-0.c │ │ │ │ │ ├── code_gen-0.in │ │ │ │ │ ├── code_gen-1.c │ │ │ │ │ ├── code_gen-1.in │ │ │ │ │ ├── code_gen-2.c │ │ │ │ │ ├── code_gen-2.in │ │ │ │ │ ├── collard-0.c │ │ │ │ │ ├── collard-0.in │ │ │ │ │ ├── dagstuhl1-0.c │ │ │ │ │ ├── dagstuhl1-0.in │ │ │ │ │ ├── dagstuhl1-1.c │ │ │ │ │ ├── dagstuhl1-1.in │ │ │ │ │ ├── fc1-0.c │ │ │ │ │ ├── fc1-0.in │ │ │ │ │ ├── fc1-1.c │ │ │ │ │ ├── fc1-1.in │ │ │ │ │ ├── fc1-2.c │ │ │ │ │ ├── fc1-2.in │ │ │ │ │ ├── fc2-0.c │ │ │ │ │ ├── fc2-0.in │ │ │ │ │ ├── fc2-1.c │ │ │ │ │ ├── fc2-1.in │ │ │ │ │ ├── floor_bound-0.c │ │ │ │ │ ├── floor_bound-0.in │ │ │ │ │ ├── floor_bound-1.c │ │ │ │ │ ├── floor_bound-1.in │ │ │ │ │ ├── floor_bound-2.c │ │ │ │ │ ├── floor_bound-2.in │ │ │ │ │ ├── floor_bound-3.c │ │ │ │ │ ├── floor_bound-3.in │ │ │ │ │ ├── floor_bound-4.c │ │ │ │ │ ├── floor_bound-4.in │ │ │ │ │ ├── floor_bound-5.c │ │ │ │ │ ├── floor_bound-5.in │ │ │ │ │ ├── floor_bound-6.c │ │ │ │ │ ├── floor_bound-6.in │ │ │ │ │ ├── gc-0.c │ │ │ │ │ ├── gc-0.in │ │ │ │ │ ├── ge-0.c │ │ │ │ │ ├── ge-0.in │ │ │ │ │ ├── ge-1.c │ │ │ │ │ ├── ge-1.in │ │ │ │ │ ├── gist-0.c │ │ │ │ │ ├── gist-0.in │ │ │ │ │ ├── gist-1.c │ │ │ │ │ ├── gist-1.in │ │ │ │ │ ├── gist-2.c │ │ │ │ │ ├── gist-2.in │ │ │ │ │ ├── gist-3.c │ │ │ │ │ ├── gist-3.in │ │ │ │ │ ├── gist-4.c │ │ │ │ │ ├── gist-4.in │ │ │ │ │ ├── gist-5.c │ │ │ │ │ ├── gist-5.in │ │ │ │ │ ├── guard1-0.c │ │ │ │ │ ├── guard1-0.in │ │ │ │ │ ├── guard1-1.c │ │ │ │ │ ├── guard1-1.in │ │ │ │ │ ├── hpf-0.c │ │ │ │ │ ├── hpf-0.in │ │ │ │ │ ├── if_then-0.c │ │ │ │ │ ├── if_then-0.in │ │ │ │ │ ├── if_then-1.c │ │ │ │ │ ├── if_then-1.in │ │ │ │ │ ├── if_then-2.c │ │ │ │ │ ├── if_then-2.in │ │ │ │ │ ├── if_then-3.c │ │ │ │ │ ├── if_then-3.in │ │ │ │ │ ├── if_then-4.c │ │ │ │ │ ├── if_then-4.in │ │ │ │ │ ├── if_then-5.c │ │ │ │ │ ├── if_then-5.in │ │ │ │ │ ├── iter1-0.c │ │ │ │ │ ├── iter1-0.in │ │ │ │ │ ├── iter2-0.c │ │ │ │ │ ├── iter2-0.in │ │ │ │ │ ├── iter3-0.c │ │ │ │ │ ├── iter3-0.in │ │ │ │ │ ├── iter4-0.c │ │ │ │ │ ├── iter4-0.in │ │ │ │ │ ├── iter5-0.c │ │ │ │ │ ├── iter5-0.in │ │ │ │ │ ├── iter6-0.c │ │ │ │ │ ├── iter6-0.in │ │ │ │ │ ├── iter6-1.c │ │ │ │ │ ├── iter6-1.in │ │ │ │ │ ├── iter7-0.c │ │ │ │ │ ├── iter7-0.in │ │ │ │ │ ├── iter8-0.c │ │ │ │ │ ├── iter8-0.in │ │ │ │ │ ├── iter9-0.c │ │ │ │ │ ├── iter9-0.in │ │ │ │ │ ├── lefur00-0.c │ │ │ │ │ ├── lefur00-0.in │ │ │ │ │ ├── lefur01-0.c │ │ │ │ │ ├── lefur01-0.in │ │ │ │ │ ├── lefur01-1.c │ │ │ │ │ ├── lefur01-1.in │ │ │ │ │ ├── lefur03-0.c │ │ │ │ │ ├── lefur03-0.in │ │ │ │ │ ├── lefur04-0.c │ │ │ │ │ ├── lefur04-0.in │ │ │ │ │ ├── lift1-0.c │ │ │ │ │ ├── lift1-0.in │ │ │ │ │ ├── lift1-1.c │ │ │ │ │ ├── lift1-1.in │ │ │ │ │ ├── lift1-2.c │ │ │ │ │ ├── lift1-2.in │ │ │ │ │ ├── lift1-3.c │ │ │ │ │ ├── lift1-3.in │ │ │ │ │ ├── lift1-4.c │ │ │ │ │ ├── lift1-4.in │ │ │ │ │ ├── lift1-5.c │ │ │ │ │ ├── lift1-5.in │ │ │ │ │ ├── lift2-0.c │ │ │ │ │ ├── lift2-0.in │ │ │ │ │ ├── lift2-1.c │ │ │ │ │ ├── lift2-1.in │ │ │ │ │ ├── lift2-2.c │ │ │ │ │ ├── lift2-2.in │ │ │ │ │ ├── lift2-3.c │ │ │ │ │ ├── lift2-3.in │ │ │ │ │ ├── lift2-4.c │ │ │ │ │ ├── lift2-4.in │ │ │ │ │ ├── lift2-5.c │ │ │ │ │ ├── lift2-5.in │ │ │ │ │ ├── lu-0.c │ │ │ │ │ ├── lu-0.in │ │ │ │ │ ├── lu-1.c │ │ │ │ │ ├── lu-1.in │ │ │ │ │ ├── lu-2.c │ │ │ │ │ ├── lu-2.in │ │ │ │ │ ├── lu-3.c │ │ │ │ │ ├── lu-3.in │ │ │ │ │ ├── lu_ijk-0.c │ │ │ │ │ ├── lu_ijk-0.in │ │ │ │ │ ├── lu_ijk-1.c │ │ │ │ │ ├── lu_ijk-1.in │ │ │ │ │ ├── lu_ijk-2.c │ │ │ │ │ ├── lu_ijk-2.in │ │ │ │ │ ├── lu_spmd-0.c │ │ │ │ │ ├── lu_spmd-0.in │ │ │ │ │ ├── lu_spmd-1.c │ │ │ │ │ ├── lu_spmd-1.in │ │ │ │ │ ├── m1-0.c │ │ │ │ │ ├── m1-0.in │ │ │ │ │ ├── m1-1.c │ │ │ │ │ ├── m1-1.in │ │ │ │ │ ├── m10-0.c │ │ │ │ │ ├── m10-0.in │ │ │ │ │ ├── m10-1.c │ │ │ │ │ ├── m10-1.in │ │ │ │ │ ├── m11-0.c │ │ │ │ │ ├── m11-0.in │ │ │ │ │ ├── m12-0.c │ │ │ │ │ ├── m12-0.in │ │ │ │ │ ├── m12-1.c │ │ │ │ │ ├── m12-1.in │ │ │ │ │ ├── m2-0.c │ │ │ │ │ ├── m2-0.in │ │ │ │ │ ├── m2-1.c │ │ │ │ │ ├── m2-1.in │ │ │ │ │ ├── m3-0.c │ │ │ │ │ ├── m3-0.in │ │ │ │ │ ├── m4-0.c │ │ │ │ │ ├── m4-0.in │ │ │ │ │ ├── m4-1.c │ │ │ │ │ ├── m4-1.in │ │ │ │ │ ├── m7-0.c │ │ │ │ │ ├── m7-0.in │ │ │ │ │ ├── m7-1.c │ │ │ │ │ ├── m7-1.in │ │ │ │ │ ├── m8-0.c │ │ │ │ │ ├── m8-0.in │ │ │ │ │ ├── m8-1.c │ │ │ │ │ ├── m8-1.in │ │ │ │ │ ├── m9-0.c │ │ │ │ │ ├── m9-0.in │ │ │ │ │ ├── m9-1.c │ │ │ │ │ ├── m9-1.in │ │ │ │ │ ├── olda-0.c │ │ │ │ │ ├── olda-0.in │ │ │ │ │ ├── olda-1.c │ │ │ │ │ ├── olda-1.in │ │ │ │ │ ├── p.delft-0.c │ │ │ │ │ ├── p.delft-0.in │ │ │ │ │ ├── p.delft2-0.c │ │ │ │ │ ├── p.delft2-0.in │ │ │ │ │ ├── p6-0.c │ │ │ │ │ ├── p6-0.in │ │ │ │ │ ├── p6-1.c │ │ │ │ │ ├── p6-1.in │ │ │ │ │ ├── stride1-0.c │ │ │ │ │ ├── stride1-0.in │ │ │ │ │ ├── stride2-0.c │ │ │ │ │ ├── stride2-0.in │ │ │ │ │ ├── stride3-0.c │ │ │ │ │ ├── stride3-0.in │ │ │ │ │ ├── stride4-0.c │ │ │ │ │ ├── stride4-0.in │ │ │ │ │ ├── stride5-0.c │ │ │ │ │ ├── stride5-0.in │ │ │ │ │ ├── stride6-0.c │ │ │ │ │ ├── stride6-0.in │ │ │ │ │ ├── stride6-1.c │ │ │ │ │ ├── stride6-1.in │ │ │ │ │ ├── stride6-2.c │ │ │ │ │ ├── stride6-2.in │ │ │ │ │ ├── stride7-0.c │ │ │ │ │ ├── stride7-0.in │ │ │ │ │ ├── stride7-1.c │ │ │ │ │ ├── stride7-1.in │ │ │ │ │ ├── substitution-0.c │ │ │ │ │ ├── substitution-0.in │ │ │ │ │ ├── substitution-1.c │ │ │ │ │ ├── substitution-1.in │ │ │ │ │ ├── substitution-2.c │ │ │ │ │ ├── substitution-2.in │ │ │ │ │ ├── substitution-3.c │ │ │ │ │ ├── substitution-3.in │ │ │ │ │ ├── substitution-4.c │ │ │ │ │ ├── substitution-4.in │ │ │ │ │ ├── syr2k-0.c │ │ │ │ │ ├── syr2k-0.in │ │ │ │ │ ├── syr2k-1.c │ │ │ │ │ ├── syr2k-1.in │ │ │ │ │ ├── syr2k-2.c │ │ │ │ │ ├── syr2k-2.in │ │ │ │ │ ├── syr2k-3.c │ │ │ │ │ ├── syr2k-3.in │ │ │ │ │ ├── ts1d-check-sblock-0.c │ │ │ │ │ ├── ts1d-check-sblock-0.in │ │ │ │ │ ├── ts1d-check0-0.c │ │ │ │ │ ├── ts1d-check0-0.in │ │ │ │ │ ├── ts1d-mp-i_ts-m_b-0.c │ │ │ │ │ ├── ts1d-mp-i_ts-m_b-0.in │ │ │ │ │ ├── ts1d-orig0-0.c │ │ │ │ │ ├── ts1d-orig0-0.in │ │ │ │ │ ├── wak1-0.c │ │ │ │ │ ├── wak1-0.in │ │ │ │ │ ├── wak1-1.c │ │ │ │ │ ├── wak1-1.in │ │ │ │ │ ├── wak2-0.c │ │ │ │ │ ├── wak2-0.in │ │ │ │ │ ├── wak2-1.c │ │ │ │ │ ├── wak2-1.in │ │ │ │ │ ├── wak3-0.c │ │ │ │ │ ├── wak3-0.in │ │ │ │ │ ├── wak3-1.c │ │ │ │ │ ├── wak3-1.in │ │ │ │ │ ├── wak4-0.c │ │ │ │ │ ├── wak4-0.in │ │ │ │ │ ├── wak4-1.c │ │ │ │ │ ├── wak4-1.in │ │ │ │ │ ├── x-0.c │ │ │ │ │ ├── x-0.in │ │ │ │ │ ├── x-1.c │ │ │ │ │ └── x-1.in │ │ │ │ ├── pldi2012 │ │ │ │ │ ├── README │ │ │ │ │ ├── figure7_b.c │ │ │ │ │ ├── figure7_b.in │ │ │ │ │ ├── figure7_c.c │ │ │ │ │ ├── figure7_c.in │ │ │ │ │ ├── figure7_d.c │ │ │ │ │ ├── figure7_d.in │ │ │ │ │ ├── figure8_a.c │ │ │ │ │ ├── figure8_a.in │ │ │ │ │ ├── figure8_b.c │ │ │ │ │ └── figure8_b.in │ │ │ │ ├── redundant.c │ │ │ │ ├── redundant.st │ │ │ │ ├── roman.c │ │ │ │ ├── roman.in │ │ │ │ ├── separate.c │ │ │ │ ├── separate.in │ │ │ │ ├── separate.st │ │ │ │ ├── separate2.c │ │ │ │ ├── separate2.in │ │ │ │ ├── separation_class.c │ │ │ │ ├── separation_class.in │ │ │ │ ├── separation_class2.c │ │ │ │ ├── separation_class2.in │ │ │ │ ├── separation_class3.c │ │ │ │ ├── separation_class3.in │ │ │ │ ├── separation_class4.c │ │ │ │ ├── separation_class4.in │ │ │ │ ├── shift.c │ │ │ │ ├── shift.in │ │ │ │ ├── shift2.c │ │ │ │ ├── shift2.in │ │ │ │ ├── shift_unroll.c │ │ │ │ ├── shift_unroll.in │ │ │ │ ├── single_valued.c │ │ │ │ ├── single_valued.in │ │ │ │ ├── sor1d-part.c │ │ │ │ ├── sor1d-part.st │ │ │ │ ├── stride.c │ │ │ │ ├── stride.in │ │ │ │ ├── stride5.c │ │ │ │ ├── stride5.in │ │ │ │ ├── stride6.c │ │ │ │ ├── stride6.in │ │ │ │ ├── stride7.c │ │ │ │ ├── stride7.in │ │ │ │ ├── unroll.c │ │ │ │ ├── unroll.in │ │ │ │ ├── unroll10.c │ │ │ │ ├── unroll10.in │ │ │ │ ├── unroll10.st │ │ │ │ ├── unroll11.c │ │ │ │ ├── unroll11.in │ │ │ │ ├── unroll2.c │ │ │ │ ├── unroll2.in │ │ │ │ ├── unroll3.c │ │ │ │ ├── unroll3.in │ │ │ │ ├── unroll4.c │ │ │ │ ├── unroll4.in │ │ │ │ ├── unroll6.c │ │ │ │ ├── unroll6.in │ │ │ │ ├── unroll7.c │ │ │ │ ├── unroll7.in │ │ │ │ ├── unroll8.c │ │ │ │ ├── unroll8.st │ │ │ │ ├── unroll9.c │ │ │ │ └── unroll9.st │ │ │ ├── convex0.polylib │ │ │ ├── convex1.polylib │ │ │ ├── convex10.polylib │ │ │ ├── convex11.polylib │ │ │ ├── convex12.polylib │ │ │ ├── convex13.polylib │ │ │ ├── convex14.polylib │ │ │ ├── convex15.polylib │ │ │ ├── convex2.polylib │ │ │ ├── convex3.polylib │ │ │ ├── convex4.polylib │ │ │ ├── convex5.polylib │ │ │ ├── convex6.polylib │ │ │ ├── convex7.polylib │ │ │ ├── convex8.polylib │ │ │ ├── convex9.polylib │ │ │ ├── devos.pwqp │ │ │ ├── equality1.pwqp │ │ │ ├── equality2.pwqp │ │ │ ├── equality3.pwqp │ │ │ ├── equality4.pwqp │ │ │ ├── equality5.pwqp │ │ │ ├── esced.pip │ │ │ ├── ex.pip │ │ │ ├── ex2.pip │ │ │ ├── exist.pip │ │ │ ├── exist2.pip │ │ │ ├── faddeev.pwqp │ │ │ ├── fimmel.pip │ │ │ ├── flow │ │ │ │ ├── kill_loop-tree.ai │ │ │ │ ├── kill_loop-tree.flow │ │ │ │ ├── kill_loop.ai │ │ │ │ ├── kill_loop.flow │ │ │ │ ├── kill_loop2-tree.ai │ │ │ │ ├── kill_loop2-tree.flow │ │ │ │ ├── kill_loop2.ai │ │ │ │ ├── kill_loop2.flow │ │ │ │ ├── kill_loop3-tree.ai │ │ │ │ ├── kill_loop3-tree.flow │ │ │ │ ├── kill_loop3.ai │ │ │ │ ├── kill_loop3.flow │ │ │ │ ├── kill_may_loop-tree.ai │ │ │ │ ├── kill_may_loop-tree.flow │ │ │ │ ├── kill_may_loop.ai │ │ │ │ ├── kill_may_loop.flow │ │ │ │ ├── kill_may_loop2-tree.ai │ │ │ │ ├── kill_may_loop2-tree.flow │ │ │ │ ├── kill_may_loop2.ai │ │ │ │ ├── kill_may_loop2.flow │ │ │ │ ├── kill_may_loop3-tree.ai │ │ │ │ ├── kill_may_loop3-tree.flow │ │ │ │ ├── kill_may_loop3.ai │ │ │ │ ├── kill_may_loop3.flow │ │ │ │ ├── loop-tree.ai │ │ │ │ ├── loop-tree.flow │ │ │ │ ├── loop.ai │ │ │ │ ├── loop.flow │ │ │ │ ├── may_loop-tree.ai │ │ │ │ ├── may_loop-tree.flow │ │ │ │ ├── may_loop.ai │ │ │ │ ├── may_loop.flow │ │ │ │ ├── mixed_loop-tree.ai │ │ │ │ ├── mixed_loop-tree.flow │ │ │ │ ├── mixed_loop.ai │ │ │ │ ├── mixed_loop.flow │ │ │ │ ├── multi.ai │ │ │ │ ├── multi.flow │ │ │ │ ├── multi_source-tree.ai │ │ │ │ ├── multi_source-tree.flow │ │ │ │ ├── multi_source.ai │ │ │ │ ├── multi_source.flow │ │ │ │ ├── multi_source2-tree.ai │ │ │ │ ├── multi_source2-tree.flow │ │ │ │ ├── multi_source2.ai │ │ │ │ ├── multi_source2.flow │ │ │ │ ├── multi_source3-tree.ai │ │ │ │ ├── multi_source3-tree.flow │ │ │ │ ├── multi_source3.ai │ │ │ │ ├── multi_source3.flow │ │ │ │ ├── multi_source4-tree.ai │ │ │ │ ├── multi_source4-tree.flow │ │ │ │ ├── multi_source4.ai │ │ │ │ ├── multi_source4.flow │ │ │ │ ├── no_source-tree.ai │ │ │ │ ├── no_source-tree.flow │ │ │ │ ├── no_source.ai │ │ │ │ ├── no_source.flow │ │ │ │ ├── no_source2-tree.ai │ │ │ │ ├── no_source2-tree.flow │ │ │ │ ├── no_source2.ai │ │ │ │ ├── no_source2.flow │ │ │ │ ├── single_may_source-tree.ai │ │ │ │ ├── single_may_source-tree.flow │ │ │ │ ├── single_may_source.ai │ │ │ │ ├── single_may_source.flow │ │ │ │ ├── single_source-tree.ai │ │ │ │ ├── single_source-tree.flow │ │ │ │ ├── single_source.ai │ │ │ │ └── single_source.flow │ │ │ ├── gist1.polylib │ │ │ ├── linearExample.pwqp │ │ │ ├── max.pip │ │ │ ├── neg.pwqp │ │ │ ├── negative.pip │ │ │ ├── philippe.pwqp │ │ │ ├── philippe3vars.pwqp │ │ │ ├── philippe3vars3pars.pwqp │ │ │ ├── philippeNeg.pwqp │ │ │ ├── philippePolynomialCoeff.pwqp │ │ │ ├── philippePolynomialCoeff1P.pwqp │ │ │ ├── product.pwqp │ │ │ ├── schedule │ │ │ │ ├── bounded_coefficients.sc │ │ │ │ ├── bounded_coefficients.st │ │ │ │ ├── carry_bounded_coefficients.sc │ │ │ │ ├── carry_bounded_coefficients.st │ │ │ │ ├── disjunctive_domain.sc │ │ │ │ ├── disjunctive_domain.st │ │ │ │ ├── feautrier_compressed.sc │ │ │ │ ├── feautrier_compressed.st │ │ │ │ ├── max_coincidence.sc │ │ │ │ ├── max_coincidence.st │ │ │ │ ├── nomax_coincidence.sc │ │ │ │ └── nomax_coincidence.st │ │ │ ├── seghir-vd.pip │ │ │ ├── set.omega │ │ │ ├── small.pip │ │ │ ├── sor1d.pip │ │ │ ├── split.pwqp │ │ │ ├── square.pip │ │ │ ├── sven.pip │ │ │ ├── test3Deg3Var.pwqp │ │ │ ├── tobi.pip │ │ │ ├── toplas.pwqp │ │ │ └── unexpanded.pwqp │ │ ├── uset_from_umap.c │ │ └── uset_to_umap.c │ ├── isl_config.h.cmake │ ├── isl_srcdir.c.cmake │ ├── pet │ │ └── include │ │ │ └── pet.h │ ├── ppcg │ │ ├── ChangeLog │ │ ├── GIT_HEAD_ID │ │ ├── Makefile.am │ │ ├── Makefile.in │ │ ├── README │ │ ├── aclocal.m4 │ │ ├── compile │ │ ├── config.guess │ │ ├── config.sub │ │ ├── configure │ │ ├── configure.ac │ │ ├── cpu.c │ │ ├── cpu.h │ │ ├── cuda.c │ │ ├── cuda.h │ │ ├── cuda_common.c │ │ ├── cuda_common.h │ │ ├── depcomp │ │ ├── external.c │ │ ├── gpu.c │ │ ├── gpu.h │ │ ├── gpu_array_tile.c │ │ ├── gpu_array_tile.h │ │ ├── gpu_group.c │ │ ├── gpu_group.h │ │ ├── gpu_hybrid.c │ │ ├── gpu_hybrid.h │ │ ├── gpu_print.c │ │ ├── gpu_print.h │ │ ├── gpu_tree.c │ │ ├── gpu_tree.h │ │ ├── grouping.c │ │ ├── hybrid.c │ │ ├── hybrid.h │ │ ├── install-sh │ │ ├── ltmain.sh │ │ ├── m4 │ │ │ ├── ax_check_opencl.m4 │ │ │ ├── ax_check_openmp.m4 │ │ │ ├── ax_detect_git_head.m4 │ │ │ ├── ax_submodule.m4 │ │ │ ├── libtool.m4 │ │ │ ├── ltoptions.m4 │ │ │ ├── ltsugar.m4 │ │ │ ├── ltversion.m4 │ │ │ └── lt~obsolete.m4 │ │ ├── missing │ │ ├── ocl_utilities.c │ │ ├── ocl_utilities.h │ │ ├── opencl.h │ │ ├── opencl_test.sh.in │ │ ├── polybench_test.sh.in │ │ ├── ppcg.c │ │ ├── ppcg.h │ │ ├── ppcg_options.c │ │ ├── ppcg_options.h │ │ ├── print.c │ │ ├── print.h │ │ ├── schedule.c │ │ ├── schedule.h │ │ ├── test-driver │ │ ├── tests │ │ │ ├── allow-sparse-copy-in.c │ │ │ ├── call.c │ │ │ ├── call2.c │ │ │ ├── call2_opencl_functions.cl │ │ │ ├── call3.c │ │ │ ├── call3_opencl_functions.cl │ │ │ ├── call_opencl_functions.cl │ │ │ ├── dead.c │ │ │ ├── iterator.c │ │ │ ├── live_out.c │ │ │ ├── local.c │ │ │ ├── loop.c │ │ │ ├── not_accessed.c │ │ │ ├── not_accessed_opencl_functions.cl │ │ │ ├── scalar.c │ │ │ ├── shared_sink.c │ │ │ ├── struct.c │ │ │ ├── struct2.c │ │ │ ├── struct3.c │ │ │ └── struct4.c │ │ ├── util.c │ │ ├── util.h │ │ └── version.c │ └── update-isl.sh ├── Polly.cpp ├── Support │ ├── DumpModulePass.cpp │ ├── GICHelper.cpp │ ├── ISLTools.cpp │ ├── Mainpage.h │ ├── PollyPasses.def │ ├── RegisterPasses.cpp │ ├── SCEVAffinator.cpp │ ├── SCEVValidator.cpp │ ├── ScopHelper.cpp │ ├── ScopLocation.cpp │ └── VirtualInstruction.cpp └── Transform │ ├── Canonicalization.cpp │ ├── CodePreparation.cpp │ ├── DeLICM.cpp │ ├── DeadCodeElimination.cpp │ ├── FlattenAlgo.cpp │ ├── FlattenSchedule.cpp │ ├── ForwardOpTree.cpp │ ├── MaximalStaticExpansion.cpp │ ├── RewriteByReferenceParameters.cpp │ ├── ScheduleOptimizer.cpp │ ├── ScheduleTreeTransform.cpp │ ├── ScopInliner.cpp │ ├── Simplify.cpp │ └── ZoneAlgo.cpp ├── test ├── CMakeLists.txt ├── CodeGen │ ├── Intrinsics │ │ └── llvm-expect.ll │ ├── OpenMP │ │ └── floord-as-argument-to-subfunction.ll │ ├── kernel_gemm___%for.cond.1.preheader---%for.end.12.jscop │ └── stride_detection.ll ├── DeLICM │ ├── confused_order.ll │ ├── confused_order___%for.end103---%for.inc116.jscop │ ├── confused_order___%for.end103---%for.inc116.jscop.transformed │ ├── contradicting_assumed_context_and_domain.ll │ ├── map_memset_zero.ll │ ├── nomap_alreadymapped.ll │ ├── nomap_escaping.ll │ ├── nomap_occupied.ll │ ├── nomap_readonly.ll │ ├── nomap_spuriouswrite.ll │ ├── nomap_storagesize.ll │ ├── nomap_writewrite.ll │ ├── outofquota-reverseDomain.ll │ ├── pass_existence.ll │ ├── pr41656.ll │ ├── reduction.ll │ ├── reduction_constant_selfconflict.ll │ ├── reduction_looprotate.ll │ ├── reduction_looprotate_alwaystaken.ll │ ├── reduction_looprotate_gvnpre.ll │ ├── reduction_looprotate_gvnpre_cond1.ll │ ├── reduction_looprotate_gvnpre_cond2.ll │ ├── reduction_looprotate_gvnpre_nopreheader.ll │ ├── reduction_looprotate_hoisted.ll │ ├── reduction_looprotate_licm.ll │ ├── reduction_looprotate_licm2.ll │ ├── reduction_looprotate_licm_double_write.ll │ ├── reduction_looprotate_licm_nopreheader.ll │ ├── reduction_looprotate_load.ll │ ├── reduction_looprotate_loopguard_gvnpre.ll │ ├── reduction_looprotate_loopguard_licm1.ll │ ├── reduction_looprotate_loopguard_licm2.ll │ ├── reduction_looprotate_loopguard_licm3.ll │ ├── reduction_looprotate_readonly.ll │ ├── reduction_looprotate_synthesizable.ll │ ├── reduction_looprotate_undef.ll │ ├── reduction_overapproximate.ll │ ├── reduction_preheader.ll │ ├── reduction_unrelatedunusual.ll │ ├── reject_loadafterstore.ll │ ├── reject_outofquota.ll │ ├── reject_storeafterstore.ll │ ├── reject_storeinsubregion.ll │ ├── reject_unusualstore.ll │ ├── skip_maywrite.ll │ ├── skip_multiaccess.ll │ ├── skip_notinloop.ll │ └── skip_scalaraccess.ll ├── DeadCodeElimination │ ├── chained_iterations.ll │ ├── chained_iterations_2.ll │ ├── computeout.ll │ ├── dead_iteration_elimination.ll │ ├── non-affine-affine-mix.ll │ ├── non-affine.ll │ └── null_schedule.ll ├── DependenceInfo │ ├── computeout.ll │ ├── different_schedule_dimensions.ll │ ├── do_pluto_matmult.ll │ ├── fine_grain_dep_0.ll │ ├── generate_may_write_dependence_info.ll │ ├── infeasible_context.ll │ ├── may_writes_do_not_block_must_writes_for_war.ll │ ├── nonaffine-condition-buildMemoryAccess.ll │ ├── reduction_complex_location.ll │ ├── reduction_dependences_equal_non_reduction_dependences.ll │ ├── reduction_dependences_not_null.ll │ ├── reduction_mixed_reduction_and_non_reduction_dependences.ll │ ├── reduction_multiple_loops_array_sum.ll │ ├── reduction_multiple_loops_array_sum_2.ll │ ├── reduction_multiple_loops_array_sum_3.ll │ ├── reduction_multiple_reductions.ll │ ├── reduction_multiple_reductions_2.ll │ ├── reduction_only_reduction_like_access.ll │ ├── reduction_partially_escaping_intermediate_in_other_stmt.ll │ ├── reduction_privatization_deps.ll │ ├── reduction_privatization_deps_2.ll │ ├── reduction_privatization_deps_3.ll │ ├── reduction_privatization_deps_4.ll │ ├── reduction_privatization_deps_5.ll │ ├── reduction_sequence.ll │ ├── reduction_simple_iv.ll │ ├── reduction_simple_iv_debug_wrapped_dependences.ll │ ├── reduction_simple_privatization_deps_2.ll │ ├── reduction_simple_privatization_deps_w_parameter.ll │ ├── reduction_two_reductions_different_rloops.ll │ └── sequential_loops.ll ├── FlattenSchedule │ └── gemm.ll ├── ForwardOpTree │ ├── atax.ll │ ├── forward_from_region.ll │ ├── forward_hoisted.ll │ ├── forward_instruction.ll │ ├── forward_into_region.ll │ ├── forward_into_region_redundant_use.ll │ ├── forward_load.ll │ ├── forward_load_differentarray.ll │ ├── forward_load_double_write.ll │ ├── forward_load_fromloop.ll │ ├── forward_load_indirect.ll │ ├── forward_load_memset_after.ll │ ├── forward_load_memset_before.ll │ ├── forward_load_tripleuse.ll │ ├── forward_load_unrelatedunusual.ll │ ├── forward_phi_load.ll │ ├── forward_readonly.ll │ ├── forward_store.ll │ ├── forward_synthesizable_definloop.ll │ ├── forward_synthesizable_indvar.ll │ ├── forward_synthesizable_useinloop.ll │ ├── forward_transitive.ll │ ├── jacobi-1d.ll │ ├── noforward_from_region.ll │ ├── noforward_load_conditional.ll │ ├── noforward_load_writebetween.ll │ ├── noforward_outofquota.ll │ ├── noforward_partial.ll │ ├── noforward_phi.ll │ ├── noforward_selfrefphi.ll │ ├── noforward_sideffects.ll │ └── noforward_synthesizable_unknownit.ll ├── GPGPU │ ├── Inputs │ │ └── libdevice-functions-copied-into-kernel_libdevice.ll │ ├── add-scalars-in-scop-to-kills.ll │ ├── align-params-in-schedule.ll │ ├── array-with-elem-type-smaller-than-byte.ll │ ├── bounds-construction-with-ignore-param-bounds.ll │ ├── check-unused-fortran-array-size-param-offloaded-to-kernel.ll │ ├── cuda-annotations.ll │ ├── cuda-managed-memory-simple.ll │ ├── debug-metadata-leak.ll │ ├── double-parallel-loop.ll │ ├── failing-invariant-load-handling.ll │ ├── failing-invariant-load-hoisting.ll │ ├── host-control-flow.ll │ ├── host-statement.ll │ ├── ignore-parameter-bounds.ll │ ├── intrinsic-copied-into-kernel.ll │ ├── invalid-kernel-assert-verifymodule.ll │ ├── invalid-kernel.ll │ ├── invariant-load-array-access.ll │ ├── invariant-load-escaping-values.ll │ ├── invariant-load-hoisting-of-array.ll │ ├── invariant-load-hoisting-read-in-kernel.ll │ ├── invariant-load-hoisting-with-variable-bounds.ll │ ├── invariant-load-hoisting-with-variable-lower-bound.ll │ ├── invariant-load-hoisting-with-variable-upper-bound.ll │ ├── invariant-load-hoisting.ll │ ├── invariant-load-of-scalar.ll │ ├── kernel-params-only-some-arrays.ll │ ├── kernel-params-scop-parameter.ll │ ├── kernels-names-across-scops-funcs.ll │ ├── libdevice-functions-copied-into-kernel.ll │ ├── live-range-reordering-with-privatization.ll │ ├── loops-outside-scop.ll │ ├── managed-memory-rewrite-alloca.ll │ ├── managed-memory-rewrite-malloc-free-inside-constexpr.ll │ ├── managed-memory-rewrite-malloc-free.ll │ ├── managed-pointers-preparation.ll │ ├── memory-only-referenced-from-access.ll │ ├── mostly-sequential.ll │ ├── non-read-only-scalars.ll │ ├── non-zero-array-offset.ll │ ├── only-part-of-array-modified.ll │ ├── parametric-loop-bound.ll │ ├── partial_writes.ll │ ├── partial_writes___%bb2---%bb14.jscop │ ├── phi-nodes-in-kernel.ll │ ├── private-memory.ll │ ├── privatization-simple.ll │ ├── privatization.ll │ ├── region-stmt.ll │ ├── remove-dead-instructions-in-stmt-2.ll │ ├── remove-dead-instructions-in-stmt.ll │ ├── run-time-check.ll │ ├── scalar-param-and-value-32-bit.ll │ ├── scalar-param-and-value-use.ll │ ├── scalar-parameter-fp128.ll │ ├── scalar-parameter-half.ll │ ├── scalar-parameter-i120.ll │ ├── scalar-parameter-i128.ll │ ├── scalar-parameter-i3000.ll │ ├── scalar-parameter-i80.ll │ ├── scalar-parameter-ppc_fp128.ll │ ├── scalar-parameter-x86_fp80.ll │ ├── scalar-parameter.ll │ ├── scalar-writes-in-scop-requires-abort.ll │ ├── scheduler-timeout.ll │ ├── shared-memory-scalar.ll │ ├── shared-memory-two-dimensional.ll │ ├── shared-memory.ll │ ├── simple-managed-memory-rewrite.ll │ ├── size-cast.ll │ ├── spir-codegen.ll │ ├── spir-typesize.ll │ ├── unknown-fn-call-not-copied-into-kernel.ll │ └── untouched-arrays.ll ├── Isl │ ├── Ast │ │ ├── OpenMP │ │ │ ├── multiple_loops_outer_parallel.ll │ │ │ ├── nested_loop_both_parallel.ll │ │ │ ├── nested_loop_both_parallel_parametric.ll │ │ │ ├── nested_loop_inner_parallel.ll │ │ │ ├── nested_loop_outer_parallel.ll │ │ │ ├── single_loop_param_non_parallel.ll │ │ │ ├── single_loop_param_parallel.ll │ │ │ └── single_loop_param_parallel_computeout.ll │ │ ├── alias_checks_with_empty_context.ll │ │ ├── alias_simple_1.ll │ │ ├── alias_simple_2.ll │ │ ├── alias_simple_3.ll │ │ ├── aliasing_arrays_with_identical_base.ll │ │ ├── aliasing_multiple_alias_groups.ll │ │ ├── aliasing_parametric_simple_1.ll │ │ ├── aliasing_parametric_simple_2.ll │ │ ├── dependence_distance_constant.ll │ │ ├── dependence_distance_minimal.ll │ │ ├── dependence_distance_multiple_constant.ll │ │ ├── dependence_distance_parametric.ll │ │ ├── dependence_distance_parametric_expr.ll │ │ ├── dependence_distance_varying.ll │ │ ├── dependence_distance_varying_in_outer_loop.ll │ │ ├── dependence_distance_varying_multiple.ll │ │ ├── domain_bounded_only_with_context.ll │ │ ├── non_affine_access.ll │ │ ├── reduction_clauses_multidimensional_access.ll │ │ ├── reduction_clauses_onedimensional_access.ll │ │ ├── reduction_dependences_equal_non_reduction_dependences.ll │ │ ├── reduction_different_reduction_clauses.ll │ │ ├── reduction_in_one_dimension.ll │ │ ├── reduction_loop_reversal.ll │ │ ├── reduction_modulo_and_loop_reversal_schedule.ll │ │ ├── reduction_modulo_and_loop_reversal_schedule_2.ll │ │ ├── reduction_modulo_schedule.ll │ │ ├── reduction_modulo_schedule_multiple_dimensions.ll │ │ ├── reduction_modulo_schedule_multiple_dimensions_2.ll │ │ ├── reduction_modulo_schedule_multiple_dimensions_3.ll │ │ ├── reduction_modulo_schedule_multiple_dimensions_4.ll │ │ ├── reduction_modulo_schedule_multiple_dimensions_5.ll │ │ ├── reduction_multiple_dimensions.ll │ │ ├── reduction_multiple_dimensions_2.ll │ │ ├── reduction_multiple_dimensions_3.ll │ │ ├── reduction_multiple_dimensions_4.ll │ │ ├── rlr___%for.cond---%for.end10.jscop │ │ ├── rmalrs2___%for.cond---%for.end10.jscop │ │ ├── rmalrs___%for.cond---%for.end10.jscop │ │ ├── rmd2___%for.cond---%for.end12.jscop │ │ ├── rmd3___%for.cond---%for.end12.jscop │ │ ├── rmd4___%for.cond---%for.end12.jscop │ │ ├── rmd___%for.cond---%for.end12.jscop │ │ ├── rms___%for.cond---%for.end10.jscop │ │ ├── rmsmd2___%for.cond---%for.end6.jscop │ │ ├── rmsmd3___%for.cond---%for.end6.jscop │ │ ├── rmsmd4___%for.cond---%for.end6.jscop │ │ ├── rmsmd5___%for.cond---%for.end6.jscop │ │ ├── rmsmd___%for.cond---%for.end6.jscop │ │ ├── run-time-condition.ll │ │ ├── runtime_context_with_error_blocks.ll │ │ ├── simple-run-time-condition.ll │ │ ├── single_loop_strip_mine.ll │ │ └── single_loop_strip_mine___%for.cond---%for.end.jscop │ ├── CodeGen │ │ ├── 20100617.ll │ │ ├── 20100622.ll │ │ ├── 20100707.ll │ │ ├── 20100707_2.ll │ │ ├── 20100708.ll │ │ ├── 20100708_2.ll │ │ ├── 20100713.ll │ │ ├── 20100713_2.ll │ │ ├── 20100717.ll │ │ ├── 20100718-DomInfo-2.ll │ │ ├── 20100718-DomInfo.ll │ │ ├── 20100720-MultipleConditions.ll │ │ ├── 20100809-IndependentBlock.ll │ │ ├── 20100811-ScalarDependencyBetweenBrAndCnd.ll │ │ ├── 20101030-Overflow.ll │ │ ├── 20101103-Overflow3.ll │ │ ├── 20101103-signmissmatch.ll │ │ ├── 20110226-Ignore-Dead-Code.ll │ │ ├── 20110226-PHI-Node-removed.ll │ │ ├── 20120316-InvalidCast.ll │ │ ├── 20120403-RHS-type-mismatch.ll │ │ ├── 20130211-getNumberOfIterations.ll │ │ ├── 20130221.ll │ │ ├── 20150328-SCEVExpanderIntroducesNewIV.ll │ │ ├── LoopParallelMD │ │ │ ├── do_not_mutate_debug_info.ll │ │ │ ├── loop_nest_param_parallel.ll │ │ │ └── single_loop_param_parallel.ll │ │ ├── MemAccess │ │ │ ├── bad_alignment.ll │ │ │ ├── bad_alignment___%for.cond---%for.end.jscop │ │ │ ├── codegen_address_space.ll │ │ │ ├── codegen_constant_offset.ll │ │ │ ├── codegen_constant_offset___%for.cond---%for.end.jscop │ │ │ ├── codegen_constant_offset___%for.cond---%for.end.jscop.transformed │ │ │ ├── codegen_simple.ll │ │ │ ├── codegen_simple___%for.cond---%for.end.jscop │ │ │ ├── codegen_simple___%for.cond---%for.end.jscop.transformed │ │ │ ├── codegen_simple_float.ll │ │ │ ├── codegen_simple_md.ll │ │ │ ├── codegen_simple_md___%for.cond---%for.end6.jscop │ │ │ ├── codegen_simple_md___%for.cond---%for.end6.jscop.transformed+withconst │ │ │ ├── codegen_simple_md___%for.cond---%for.end6.jscop.transformed+withoutconst │ │ │ ├── codegen_simple_md_float.ll │ │ │ ├── create_arrays.ll │ │ │ ├── create_arrays___%bb9---%bb26.jscop │ │ │ ├── create_arrays___%bb9---%bb26.jscop.transformed │ │ │ ├── create_arrays_heap.ll │ │ │ ├── create_arrays_heap___%for.cond1.preheader---%for.end18.jscop │ │ │ ├── create_arrays_heap___%for.cond1.preheader---%for.end18.jscop.transformed │ │ │ ├── default_aligned_new_access_function.ll │ │ │ ├── different_types.ll │ │ │ ├── different_types___%bb2---%bb18.jscop │ │ │ ├── generate-all.ll │ │ │ ├── invariant_base_ptr.ll │ │ │ ├── invariant_base_ptr___%loop---%exit.jscop │ │ │ ├── map_scalar_access.ll │ │ │ ├── map_scalar_access___%outer.for---%return.jscop │ │ │ ├── map_scalar_access___%outer.for---%return.jscop.transformed │ │ │ ├── multiple_types.ll │ │ │ ├── multiple_types___%bb1---%bb22.jscop │ │ │ ├── simple.ll │ │ │ ├── simple___%for.cond---%for.end.jscop │ │ │ ├── simple___%for.cond---%for.end.jscop.transformed │ │ │ ├── simple___%for.cond---%for.end14.jscop │ │ │ ├── simple___%for.cond---%for.end14.jscop.transformed │ │ │ ├── simple___%for.cond4---%for.end14.jscop │ │ │ ├── simple___%for.cond4---%for.end14.jscop.transformed │ │ │ ├── simple_analyze.ll │ │ │ ├── simple_stride___%for.cond---%for.end.jscop │ │ │ ├── simple_stride_test.ll │ │ │ ├── update_access_functions.ll │ │ │ ├── update_access_functions___%loop1---%exit.jscop │ │ │ └── update_access_functions___%loop1---%exit.jscop.transformed │ │ ├── OpenMP │ │ │ ├── alias-metadata.ll │ │ │ ├── invariant_base_pointer_preloaded.ll │ │ │ ├── invariant_base_pointer_preloaded_different_bb.ll │ │ │ ├── invariant_base_pointer_preloaded_pass_only_needed.ll │ │ │ ├── invariant_base_pointers_preloaded.ll │ │ │ ├── loop-body-references-outer-iv.ll │ │ │ ├── loop-body-references-outer-values-2.ll │ │ │ ├── loop-body-references-outer-values-3.ll │ │ │ ├── loop-body-references-outer-values.ll │ │ │ ├── loop-bounds-reference-outer-ids.ll │ │ │ ├── mapped-phi-access.ll │ │ │ ├── matmul-parallel.ll │ │ │ ├── new_multidim_access.ll │ │ │ ├── new_multidim_access___%bb1---%bb17.jscop │ │ │ ├── recomputed-srem.ll │ │ │ ├── reference-argument-from-non-affine-region.ll │ │ │ ├── reference-other-bb.ll │ │ │ ├── reference-preceeding-loop.ll │ │ │ ├── reference_latest.ll │ │ │ ├── single_loop.ll │ │ │ ├── single_loop_with_loop_invariant_baseptr.ll │ │ │ ├── single_loop_with_param.ll │ │ │ ├── single_parallel_loop___%for.i---%exit.jscop │ │ │ └── two-parallel-loops-reference-outer-indvar.ll │ │ ├── PHIInExit.ll │ │ ├── RuntimeDebugBuilder │ │ │ ├── combine_different_values.c │ │ │ ├── combine_different_values.ll │ │ │ └── stmt_tracing.ll │ │ ├── alias-check-multi-dim.ll │ │ ├── alias_metadata_too_many_arrays.ll │ │ ├── aliasing_different_base_and_access_type.ll │ │ ├── aliasing_different_pointer_types.ll │ │ ├── aliasing_multidimensional_access.ll │ │ ├── aliasing_parametric_simple_1.ll │ │ ├── aliasing_parametric_simple_2.ll │ │ ├── aliasing_struct_element.ll │ │ ├── alignment.ll │ │ ├── annotated_alias_scopes.ll │ │ ├── blas_sscal_simplified.ll │ │ ├── conflict-between-loop-invariant-code-hosting-and-escape-map-computation.ll │ │ ├── constant_condition.ll │ │ ├── create-conditional-scop.ll │ │ ├── dead_invariant_load_instruction_referenced_by_parameter_1.ll │ │ ├── dead_invariant_load_instruction_referenced_by_parameter_2.ll │ │ ├── debug-intrinsics.ll │ │ ├── dominance_problem_after_early_codegen_bailout.ll │ │ ├── empty_domain_in_context.ll │ │ ├── entry_with_trivial_phi.ll │ │ ├── entry_with_trivial_phi_other_bb.ll │ │ ├── error-stmt-in-non-affine-region.ll │ │ ├── error_block_contains_invalid_memory_access.ll │ │ ├── exprModDiv.ll │ │ ├── exprModDiv___%for.cond---%for.end.jscop │ │ ├── exprModDiv___%for.cond---%for.end.jscop.pow2 │ │ ├── fortran_array_runtime_size_generation.ll │ │ ├── getNumberOfIterations.ll │ │ ├── hoisted_load_escapes_through_phi.ll │ │ ├── hoisting_1.ll │ │ ├── hoisting_2.ll │ │ ├── if-conditions-in-vector-code.ll │ │ ├── inner_scev_sdiv_1.ll │ │ ├── inner_scev_sdiv_2.ll │ │ ├── inner_scev_sdiv_3.ll │ │ ├── inner_scev_sdiv_in_lb.ll │ │ ├── inner_scev_sdiv_in_lb_invariant.ll │ │ ├── inner_scev_sdiv_in_rtc.ll │ │ ├── intrinsics_lifetime.ll │ │ ├── intrinsics_misc.ll │ │ ├── inv-load-lnt-crash-wrong-order-2.ll │ │ ├── inv-load-lnt-crash-wrong-order-3.ll │ │ ├── inv-load-lnt-crash-wrong-order.ll │ │ ├── invariant-load-dimension.ll │ │ ├── invariant-load-preload-base-pointer-origin-first.ll │ │ ├── invariant_cannot_handle_void.ll │ │ ├── invariant_load.ll │ │ ├── invariant_load_address_space.ll │ │ ├── invariant_load_alias_metadata.ll │ │ ├── invariant_load_base_pointer.ll │ │ ├── invariant_load_base_pointer_conditional.ll │ │ ├── invariant_load_base_pointer_conditional_2.ll │ │ ├── invariant_load_canonicalize_array_baseptrs.ll │ │ ├── invariant_load_condition.ll │ │ ├── invariant_load_different_sized_types.ll │ │ ├── invariant_load_escaping.ll │ │ ├── invariant_load_escaping_second_scop.ll │ │ ├── invariant_load_hoist_alignment.ll │ │ ├── invariant_load_in_non_affine_subregion.ll │ │ ├── invariant_load_loop_ub.ll │ │ ├── invariant_load_not_executed_but_in_parameters.ll │ │ ├── invariant_load_outermost.ll │ │ ├── invariant_load_parameters_cyclic_dependence.ll │ │ ├── invariant_load_ptr_ptr_noalias.ll │ │ ├── invariant_load_scalar_dep.ll │ │ ├── invariant_load_scalar_escape_alloca_sharing.ll │ │ ├── invariant_loads_from_struct_with_different_types_1.ll │ │ ├── invariant_loads_from_struct_with_different_types_2.ll │ │ ├── invariant_loads_ignore_parameter_bounds.ll │ │ ├── invariant_verify_function_failed.ll │ │ ├── invariant_verify_function_failed_2.ll │ │ ├── large-numbers-in-boundary-context.ll │ │ ├── load_subset_with_context.ll │ │ ├── load_subset_with_context___%for.cond7.preheader---%for.cond33.preheader.jscop │ │ ├── load_subset_with_context___%for.cond7.preheader---%for.cond33.preheader.jscop.transformed │ │ ├── loop-invariant-load-type-mismatch.ll │ │ ├── loop_with_condition.ll │ │ ├── loop_with_condition_2.ll │ │ ├── loop_with_condition_ineq.ll │ │ ├── loop_with_condition_nested.ll │ │ ├── loop_with_conditional_entry_edge_split_hard_case.ll │ │ ├── memcpy_annotations.ll │ │ ├── multidim-non-matching-typesize-2.ll │ │ ├── multidim-non-matching-typesize.ll │ │ ├── multidim_2d_parametric_array_static_loop_bounds.ll │ │ ├── multidim_alias_check.ll │ │ ├── multiple-codegens.ll │ │ ├── multiple-scops-in-a-row.ll │ │ ├── multiple-types-invariant-load-2.ll │ │ ├── multiple-types-invariant-load.ll │ │ ├── multiple_sai_fro_same_base_address.ll │ │ ├── new_multidim_access___%bb1---%bb17.jscop │ │ ├── no-overflow-tracking.ll │ │ ├── no_guard_bb.ll │ │ ├── non-affine-dominance-generated-entering.ll │ │ ├── non-affine-exit-node-dominance.ll │ │ ├── non-affine-phi-node-expansion-2.ll │ │ ├── non-affine-phi-node-expansion-3.ll │ │ ├── non-affine-phi-node-expansion-4.ll │ │ ├── non-affine-phi-node-expansion.ll │ │ ├── non-affine-region-exit-phi-incoming-synthesize-2.ll │ │ ├── non-affine-region-exit-phi-incoming-synthesize.ll │ │ ├── non-affine-region-implicit-store.ll │ │ ├── non-affine-region-phi-references-in-scop-value.ll │ │ ├── non-affine-subregion-dominance-reuse.ll │ │ ├── non-affine-switch.ll │ │ ├── non-affine-synthesized-in-branch.ll │ │ ├── non-affine-update.ll │ │ ├── non-affine-update___%bb1---%bb15.jscop │ │ ├── non-hoisted-load-needed-as-base-ptr.ll │ │ ├── non_affine_float_compare.ll │ │ ├── only_non_affine_error_region.ll │ │ ├── openmp_limit_threads.ll │ │ ├── out-of-scop-phi-node-use.ll │ │ ├── param_div_div_div_2.ll │ │ ├── partial_write_array.ll │ │ ├── partial_write_array___%for---%return.jscop │ │ ├── partial_write_array___%for---%return.jscop.transformed │ │ ├── partial_write_emptyset.ll │ │ ├── partial_write_emptyset___%for---%return.jscop │ │ ├── partial_write_emptyset___%for---%return.jscop.transformed │ │ ├── partial_write_full_write_that_appears_partial.ll │ │ ├── partial_write_impossible_restriction.ll │ │ ├── partial_write_impossible_restriction___%for.body344---%if.then.i.i1141.loopexit.jscop │ │ ├── partial_write_impossible_restriction___%for.body344---%if.then.i.i1141.loopexit.jscop.transformed │ │ ├── partial_write_in_region.ll │ │ ├── partial_write_in_region___%bb1---%bb12.jscop │ │ ├── partial_write_in_region___%bb1---%bb12.jscop.transformed │ │ ├── partial_write_in_region_with_loop.ll │ │ ├── partial_write_in_region_with_loop___%bb1---%bb14.jscop │ │ ├── partial_write_in_region_with_loop___%bb1---%bb14.jscop.transformed │ │ ├── partial_write_mapped_scalar.ll │ │ ├── partial_write_mapped_scalar___%for---%return.jscop │ │ ├── partial_write_mapped_scalar___%for---%return.jscop.transformed │ │ ├── partial_write_mapped_scalar_subregion.ll │ │ ├── partial_write_mapped_scalar_subregion___%for---%return.jscop │ │ ├── partial_write_mapped_scalar_subregion___%for---%return.jscop.transformed │ │ ├── partial_write_mapped_vector.ll │ │ ├── partial_write_mapped_vector___%for---%return.jscop │ │ ├── partial_write_mapped_vector___%for---%return.jscop.transformed │ │ ├── perf_monitoring.ll │ │ ├── perf_monitoring_cycles_per_scop.ll │ │ ├── perf_monitoring_trip_counts_per_scop.ll │ │ ├── phi-defined-before-scop.ll │ │ ├── phi_after_error_block_outside_of_scop.ll │ │ ├── phi_condition_modeling_1.ll │ │ ├── phi_condition_modeling_2.ll │ │ ├── phi_conditional_simple_1.ll │ │ ├── phi_in_exit_early_lnt_failure_1.ll │ │ ├── phi_in_exit_early_lnt_failure_2.ll │ │ ├── phi_in_exit_early_lnt_failure_3.ll │ │ ├── phi_in_exit_early_lnt_failure_5.ll │ │ ├── phi_loop_carried_float.ll │ │ ├── phi_loop_carried_float_escape.ll │ │ ├── phi_scalar_simple_1.ll │ │ ├── phi_scalar_simple_2.ll │ │ ├── phi_with_multi_exiting_edges_2.ll │ │ ├── phi_with_one_exit_edge.ll │ │ ├── pointer-type-expressions-2.ll │ │ ├── pointer-type-expressions.ll │ │ ├── pointer-type-pointer-type-comparison.ll │ │ ├── pointer_rem.ll │ │ ├── pr25241.ll │ │ ├── ptrtoint_as_parameter.ll │ │ ├── read-only-scalars.ll │ │ ├── reduction.ll │ │ ├── reduction_2.ll │ │ ├── reduction_simple_binary.ll │ │ ├── region-with-instructions.ll │ │ ├── region_exiting-domtree.ll │ │ ├── region_multiexit_partialwrite.ll │ │ ├── region_multiexit_partialwrite___%bb3---%bb19.jscop │ │ ├── region_multiexit_partialwrite___%bb3---%bb19.jscop.transformed │ │ ├── run-time-condition-with-scev-parameters.ll │ │ ├── run-time-condition.ll │ │ ├── scalar-references-used-in-scop-compute.ll │ │ ├── scalar-store-from-same-bb.ll │ │ ├── scalar_codegen_crash.ll │ │ ├── scev-division-invariant-load.ll │ │ ├── scev.ll │ │ ├── scev_expansion_in_nonaffine.ll │ │ ├── scev_looking_through_bitcasts.ll │ │ ├── scop_expander_insert_point.ll │ │ ├── scop_expander_segfault.ll │ │ ├── scop_never_executed_runtime_check_location.ll │ │ ├── select-base-pointer.ll │ │ ├── sequential_loops.ll │ │ ├── simple_loop_non_single_exit.ll │ │ ├── simple_loop_non_single_exit_2.ll │ │ ├── simple_non_single_entry.ll │ │ ├── simple_nonaffine_loop.ll │ │ ├── simple_vec_assign_scalar.ll │ │ ├── simple_vec_assign_scalar_2.ll │ │ ├── simple_vec_call.ll │ │ ├── simple_vec_call_2.ll │ │ ├── simple_vec_cast.ll │ │ ├── simple_vec_const.ll │ │ ├── simple_vec_large_width.ll │ │ ├── simple_vec_ptr_ptr_ty.ll │ │ ├── simple_vec_stride_negative_one.ll │ │ ├── simple_vec_stride_one.ll │ │ ├── simple_vec_stride_x.ll │ │ ├── simple_vec_strides_multidim.ll │ │ ├── simple_vec_two_stmts.ll │ │ ├── single_do_loop_int_max_iterations.ll │ │ ├── single_do_loop_int_max_iterations___%do.body---%do.end.jscop │ │ ├── single_do_loop_int_param_iterations.ll │ │ ├── single_do_loop_ll_max_iterations.ll │ │ ├── single_do_loop_one_iteration.ll │ │ ├── single_do_loop_scev_replace.ll │ │ ├── single_loop.ll │ │ ├── single_loop_int_max_iterations.ll │ │ ├── single_loop_ll_max_iterations.ll │ │ ├── single_loop_one_iteration.ll │ │ ├── single_loop_param.ll │ │ ├── single_loop_zero_iterations.ll │ │ ├── split_edge_of_exit.ll │ │ ├── split_edges.ll │ │ ├── split_edges_2.ll │ │ ├── srem-in-other-bb.ll │ │ ├── stack-overflow-in-load-hoisting.ll │ │ ├── stmt_split_no_dependence.ll │ │ ├── switch-in-non-affine-region.ll │ │ ├── synthesizable_phi_write_after_loop.ll │ │ ├── test-invalid-operands-for-select-2.ll │ │ ├── test-invalid-operands-for-select.ll │ │ ├── test.ll │ │ ├── two-loops-right-after-each-other-2.ll │ │ ├── two-scops-in-row-invalidate-scevs.ll │ │ ├── two-scops-in-row.ll │ │ ├── udiv_expansion_position.ll │ │ ├── uninitialized_scalar_memory.ll │ │ ├── unpredictable-loop-unsynthesizable.ll │ │ ├── variant_load_empty_domain.ll │ │ └── whole-scop-non-affine-subregion.ll │ ├── single_loop_param_less_equal.ll │ ├── single_loop_param_less_than.ll │ ├── single_loop_uint_max_iterations.ll │ └── single_loop_ull_max_iterations.ll ├── JSONExporter │ ├── ImportAccesses │ │ ├── ImportAccesses-Bad-relation.ll │ │ ├── ImportAccesses-No-accesses-key.ll │ │ ├── ImportAccesses-Not-enough-MemAcc.ll │ │ ├── ImportAccesses-Not-enough-statements.ll │ │ ├── ImportAccesses-Relation-mispelled.ll │ │ ├── ImportAccesses-Statements-mispelled.ll │ │ ├── ImportAccesses-Undeclared-ScopArrayInfo.ll │ │ ├── ImportAccesses-Wrong-number-dimensions.ll │ │ ├── ia2___%for.cond---%for.end10.jscop │ │ ├── ia3___%for.cond---%for.end10.jscop │ │ ├── ia4___%for.cond---%for.end10.jscop │ │ ├── ia5___%for.cond---%for.end10.jscop │ │ ├── ia6___%for.cond---%for.end10.jscop │ │ ├── ia7___%for.cond---%for.end10.jscop │ │ ├── ia8___%for.cond---%for.end10.jscop │ │ └── ia___%for.cond---%for.end10.jscop │ ├── ImportArrays │ │ ├── ImportArrays-Mispelled-type.ll │ │ ├── ImportArrays-Negative-size.ll │ │ ├── ImportArrays-No-name.ll │ │ ├── ImportArrays-No-sizes-key.ll │ │ ├── ImportArrays-No-type-key.ll │ │ ├── ImportArrays_Negative_Size___%for.cond1.preheader---%for.end18.jscop │ │ ├── ImportArrays_Negative_Size___%for.cond1.preheader---%for.end18.jscop.transformed │ │ ├── ia2___%bb9---%bb26.jscop.transformed │ │ ├── ia3___%bb9---%bb26.jscop.transformed │ │ ├── ia4___%bb9---%bb26.jscop.transformed │ │ └── ia___%bb9---%bb26.jscop.transformed │ ├── ImportContext │ │ ├── ImportContext-Context-mispelled.ll │ │ ├── ImportContext-Not-parameter-set.ll │ │ ├── ImportContext-Unvalid-Context.ll │ │ ├── ImportContext-Wrong-dimension.ll │ │ ├── ic2___%for.cond---%for.end10.jscop │ │ ├── ic3___%for.cond---%for.end10.jscop │ │ ├── ic4___%for.cond---%for.end10.jscop │ │ └── ic___%for.cond---%for.end10.jscop │ └── ImportSchedule │ │ ├── ImportSchedule-No-schedule-key.ll │ │ ├── ImportSchedule-Schedule-not-valid.ll │ │ ├── ImportSchedule-Statements-mispelled.ll │ │ ├── ImportSchedule-Wrong-number-statements.ll │ │ ├── is2___%for.cond---%for.end10.jscop │ │ ├── is3___%for.cond---%for.end10.jscop │ │ ├── is4___%for.cond---%for.end10.jscop │ │ └── is___%for.cond---%for.end10.jscop ├── MaximalStaticExpansion │ ├── load_after_store_same_statement.ll │ ├── read_from_original.ll │ ├── too_many_writes.ll │ ├── working_deps_between_inners.ll │ ├── working_deps_between_inners_phi.ll │ ├── working_expansion.ll │ ├── working_expansion_multiple_dependences_per_statement.ll │ ├── working_expansion_multiple_instruction_per_statement.ll │ ├── working_phi_expansion.ll │ ├── working_phi_two_scalars.ll │ └── working_value_expansion.ll ├── PruneUnprofitable │ └── prune_only_scalardeps.ll ├── README ├── RewriteByReferenceParameters │ └── fortran_io.ll ├── ScheduleOptimizer │ ├── 2012-03-16-Empty-Domain.ll │ ├── 2012-04-16-Trivially-vectorizable-loops.ll │ ├── 2013-04-11-Empty-Domain-two.ll │ ├── SIMDInParallelFor.ll │ ├── computeout.ll │ ├── ensure-correct-tile-sizes.ll │ ├── full_partial_tile_separation.ll │ ├── kernel_gemm___%for.body---%for.end24.jscop │ ├── kernel_gemm___%for.body---%for.end24.jscop.transformed │ ├── kernel_gemm___%for.cond1.preheader---%for.end18.jscop.transformed │ ├── line-tiling-2.ll │ ├── line-tiling.ll │ ├── mat_mul_pattern_data_layout.ll │ ├── mat_mul_pattern_data_layout_2.ll │ ├── one-dimensional-band.ll │ ├── outer_coincidence.ll │ ├── pattern-matching-based-opts-after-delicm.ll │ ├── pattern-matching-based-opts.ll │ ├── pattern-matching-based-opts_10.ll │ ├── pattern-matching-based-opts_11.ll │ ├── pattern-matching-based-opts_12.ll │ ├── pattern-matching-based-opts_13.ll │ ├── pattern-matching-based-opts_14.ll │ ├── pattern-matching-based-opts_2.ll │ ├── pattern-matching-based-opts_3.ll │ ├── pattern-matching-based-opts_4.ll │ ├── pattern-matching-based-opts_5.ll │ ├── pattern-matching-based-opts_6.ll │ ├── pattern-matching-based-opts_7.ll │ ├── pattern-matching-based-opts_8.ll │ ├── pattern-matching-based-opts_9.ll │ ├── pattern_matching_based_opts_splitmap.ll │ ├── pattern_matching_based_opts_splitmap___%for.body---%for.end23.jscop │ ├── pattern_matching_based_opts_splitmap___%for.body---%for.end23.jscop.transformed │ ├── prevectorization-without-tiling.ll │ ├── prevectorization.ll │ ├── rectangular-tiling.ll │ ├── statistics.ll │ └── tile_after_fusion.ll ├── ScopDetect │ ├── aliasing_parametric_simple_1.ll │ ├── aliasing_parametric_simple_2.ll │ ├── aliasing_simple_1.ll │ ├── aliasing_simple_2.ll │ ├── base_pointer.ll │ ├── base_pointer_is_inst_inside_invariant_1___%for.i---%exit.jscop │ ├── base_pointer_load_is_inst_inside_invariant_1___%for.i---%exit.jscop │ ├── base_pointer_load_setNewAccessRelation.ll │ ├── base_pointer_setNewAccessRelation.ll │ ├── collective_invariant_loads.ll │ ├── cross_loop_non_single_exit.ll │ ├── cross_loop_non_single_exit_2.ll │ ├── dependency_to_phi_node_outside_of_region.ll │ ├── dot-scops.ll │ ├── error-block-always-executed.ll │ ├── error-block-referenced-from-scop.ll │ ├── error-block-unreachable.ll │ ├── expand-region-correctly-2.ll │ ├── expand-region-correctly.ll │ ├── ignore_func_flag_regex.ll │ ├── index_from_unpredictable_loop.ll │ ├── index_from_unpredictable_loop2.ll │ ├── indvars.ll │ ├── intrinsics_1.ll │ ├── intrinsics_2.ll │ ├── intrinsics_3.ll │ ├── invalid-latch-conditions.ll │ ├── invalidate_scalar_evolution.ll │ ├── invariant-load-before-scop.ll │ ├── keep_going_expansion.ll │ ├── mod_ref_read_pointer.ll │ ├── more-than-one-loop.ll │ ├── multidim-with-undef-size.ll │ ├── multidim.ll │ ├── multidim_indirect_access.ll │ ├── multidim_two_accesses_different_delinearization.ll │ ├── nested_loop_single_exit.ll │ ├── non-affine-conditional.ll │ ├── non-affine-float-compare.ll │ ├── non-affine-loop-condition-dependent-access.ll │ ├── non-affine-loop-condition-dependent-access_2.ll │ ├── non-affine-loop-condition-dependent-access_3.ll │ ├── non-affine-loop.ll │ ├── non-beneficial-loops-small-trip-count.ll │ ├── non-constant-add-rec-start-expr.ll │ ├── non-simple-memory-accesses.ll │ ├── non_affine_loop_condition.ll │ ├── only-one-affine-loop.ll │ ├── only_func_flag.ll │ ├── only_func_flag_regex.ll │ ├── parametric-multiply-in-scev-2.ll │ ├── parametric-multiply-in-scev.ll │ ├── phi_with_multi_exiting_edges.ll │ ├── profitability-large-basic-blocks.ll │ ├── profitability-two-nested-loops.ll │ ├── remove_all_children.ll │ ├── report-scop-location.ll │ ├── restrict-undef-size-scopdetect.ll │ ├── run_time_alias_check.ll │ ├── scev_remove_max.ll │ ├── sequential_loops.ll │ ├── simple_loop.ll │ ├── simple_loop_non_single_entry.ll │ ├── simple_loop_non_single_exit.ll │ ├── simple_loop_non_single_exit_2.ll │ ├── simple_loop_two_phi_nodes.ll │ ├── simple_loop_with_param.ll │ ├── simple_loop_with_param_2.ll │ ├── simple_non_single_entry.ll │ ├── skip_function_attribute.ll │ ├── srem_with_parametric_divisor.ll │ ├── statistics.ll │ ├── switch-in-loop-patch.ll │ └── tlr_is_hoistable_load.ll ├── ScopDetectionDiagnostics │ ├── ReportAlias-01.ll │ ├── ReportEntry.ll │ ├── ReportFuncCall-01.ll │ ├── ReportIrreducibleRegion.ll │ ├── ReportIrreducibleRegionWithoutDebugLoc.ll │ ├── ReportLoopBound-01.ll │ ├── ReportLoopHasNoExit.ll │ ├── ReportMultipleNonAffineAccesses.ll │ ├── ReportNonAffineAccess-01.ll │ ├── ReportUnprofitable.ll │ ├── ReportUnreachableInExit.ll │ ├── ReportVariantBasePtr-01.ll │ ├── loop_has_multiple_exits.ll │ ├── loop_partially_in_scop-2.ll │ └── loop_partially_in_scop.ll ├── ScopInfo │ ├── 20110312-Fail-without-basicaa.ll │ ├── 20111108-Parameter-not-detected.ll │ ├── 2012-03-16-Crash-because-of-unsigned-in-scev.ll │ ├── 2015-10-04-Crash-in-domain-generation.ll │ ├── Alias-0.ll │ ├── Alias-1.ll │ ├── Alias-2.ll │ ├── Alias-3.ll │ ├── Alias-4.ll │ ├── BoundChecks │ │ ├── single-loop.ll │ │ └── two-loops.ll │ ├── NonAffine │ │ ├── div_backedge.ll │ │ ├── div_domain.ll │ │ ├── invariant_loads_dependent_in_non_affine_region.ll │ │ ├── modulo_backedge.ll │ │ ├── modulo_domain.ll │ │ ├── non-affine-loop-condition-dependent-access_1.ll │ │ ├── non-affine-loop-condition-dependent-access_2.ll │ │ ├── non-affine-loop-condition-dependent-access_3.ll │ │ ├── non_affine_access_with_range_2.ll │ │ ├── non_affine_but_sdiv.ll │ │ ├── non_affine_but_srem.ll │ │ ├── non_affine_conditional_nested.ll │ │ ├── non_affine_conditional_surrounding_affine_loop.ll │ │ ├── non_affine_conditional_surrounding_non_affine_loop.ll │ │ ├── non_affine_float_compare.ll │ │ ├── non_affine_loop_condition.ll │ │ ├── non_affine_loop_used_later.ll │ │ ├── non_affine_parametric_loop.ll │ │ ├── non_affine_region_guaranteed_non-entry.ll │ │ └── whole-scop-non-affine-subregion-in-loop.ll │ ├── aliasing_conditional_alias_groups_1.ll │ ├── aliasing_conditional_alias_groups_2.ll │ ├── aliasing_dead_access.ll │ ├── aliasing_many_arrays_to_compare.ll │ ├── aliasing_many_parameters_not_all_involved.ll │ ├── aliasing_many_read_only_acesses.ll │ ├── aliasing_multiple_alias_groups.ll │ ├── aliasing_with_non_affine_access.ll │ ├── allow-all-parameters-dereferencable.ll │ ├── assume_gep_bounds.ll │ ├── assume_gep_bounds_2.ll │ ├── assume_gep_bounds_many.ll │ ├── avoid_new_parameters_from_geps.ll │ ├── bool-addrec.ll │ ├── bounded_loop_assumptions.ll │ ├── branch-references-loop-scev-with-unknown-iterations-2.ll │ ├── branch-references-loop-scev-with-unknown-iterations-3.ll │ ├── branch-references-loop-scev-with-unknown-iterations.ll │ ├── bug_2010_10_22.ll │ ├── bug_2011_1_5.ll │ ├── bug_scev_not_fully_eval.ll │ ├── cfg_consequences.ll │ ├── complex-branch-structure.ll │ ├── complex-condition.ll │ ├── complex-expression.ll │ ├── complex-loop-nesting.ll │ ├── complex-successor-structure-2.ll │ ├── complex-successor-structure-3.ll │ ├── complex-successor-structure.ll │ ├── complex_domain_binary_condition.ll │ ├── complex_execution_context.ll │ ├── cond_constant_in_loop.ll │ ├── cond_in_loop.ll │ ├── condition-after-error-block-2.ll │ ├── condtion-after-error-block.ll │ ├── const_srem_sdiv.ll │ ├── constant-non-integer-branch-condition.ll │ ├── constant_factor_in_parameter.ll │ ├── constant_functions_as_unknowns.ll │ ├── constant_functions_multi_dim.ll │ ├── constant_functions_outside_scop_as_unknown.ll │ ├── constant_start_integer.ll │ ├── debug_call.ll │ ├── delinearize-together-all-data-refs.ll │ ├── div_by_zero.ll │ ├── do-not-model-error-block-accesses.ll │ ├── eager-binary-and-or-conditions.ll │ ├── early_exit_for_complex_domains.ll │ ├── error-blocks-1.ll │ ├── error-blocks-2.ll │ ├── error-blocks-3.ll │ ├── escaping_empty_scop.ll │ ├── exit-phi-1.ll │ ├── exit-phi-2.ll │ ├── exit_phi_accesses-2.ll │ ├── exit_phi_accesses.ll │ ├── expensive-boundary-context.ll │ ├── extract_constant_factor_introduces_new_parameter.ll │ ├── fortran_array_global_malloc_nonvectored.ll │ ├── fortran_array_global_nonmalloc_nonvectored.ll │ ├── fortran_array_param_nonmalloc_nonvectored.ll │ ├── fortran_array_param_nonmalloc_nonvectored_read_and_write.ll │ ├── full-function.ll │ ├── granularity_same_name.ll │ ├── granularity_scalar-indep.ll │ ├── granularity_scalar-indep_cross-referencing-phi1.ll │ ├── granularity_scalar-indep_cross-referencing-phi2.ll │ ├── granularity_scalar-indep_epilogue.ll │ ├── granularity_scalar-indep_epilogue_last.ll │ ├── granularity_scalar-indep_noepilogue.ll │ ├── granularity_scalar-indep_ordered-2.ll │ ├── granularity_scalar-indep_ordered.ll │ ├── i1_params.ll │ ├── infeasible-rtc.ll │ ├── infeasible_invalid_context.ll │ ├── int2ptr_ptr2int.ll │ ├── int2ptr_ptr2int_2.ll │ ├── integers.ll │ ├── inter-error-bb-dependence.ll │ ├── inter_bb_scalar_dep.ll │ ├── intra-non-affine-stmt-phi-node.ll │ ├── intra_and_inter_bb_scalar_dep.ll │ ├── intra_bb_scalar_dep.ll │ ├── intrinsics.ll │ ├── invalid_add_rec_after_invariant_load_remapping.ll │ ├── invalidate_iterator_during_MA_removal.ll │ ├── invariant-loads-leave-read-only-statements.ll │ ├── invariant_load.ll │ ├── invariant_load_access_classes_different_base_type.ll │ ├── invariant_load_access_classes_different_base_type_escaping.ll │ ├── invariant_load_access_classes_different_base_type_same_pointer.ll │ ├── invariant_load_access_classes_different_base_type_same_pointer_escaping.ll │ ├── invariant_load_addrec_sum.ll │ ├── invariant_load_base_pointer.ll │ ├── invariant_load_base_pointer_conditional.ll │ ├── invariant_load_base_pointer_in_conditional.ll │ ├── invariant_load_branch_condition.ll │ ├── invariant_load_canonicalize_array_baseptrs.ll │ ├── invariant_load_canonicalize_array_baseptrs_2.ll │ ├── invariant_load_canonicalize_array_baseptrs_3.ll │ ├── invariant_load_canonicalize_array_baseptrs_4.ll │ ├── invariant_load_canonicalize_array_baseptrs_4b.ll │ ├── invariant_load_canonicalize_array_baseptrs_4c.ll │ ├── invariant_load_canonicalize_array_baseptrs_5.ll │ ├── invariant_load_complex_condition.ll │ ├── invariant_load_condition.ll │ ├── invariant_load_dereferenceable.ll │ ├── invariant_load_distinct_parameter_valuations.ll │ ├── invariant_load_in_non_affine.ll │ ├── invariant_load_loop_ub.ll │ ├── invariant_load_ptr_ptr_noalias.ll │ ├── invariant_load_scalar_dep.ll │ ├── invariant_load_stmt_domain.ll │ ├── invariant_load_zext_parameter-2.ll │ ├── invariant_load_zext_parameter.ll │ ├── invariant_load_zextended_in_own_execution_context.ll │ ├── invariant_loads_complicated_dependences.ll │ ├── invariant_loads_cyclic_dependences.ll │ ├── invariant_loop_bounds.ll │ ├── invariant_same_loop_bound_multiple_times-1.ll │ ├── invariant_same_loop_bound_multiple_times-2.ll │ ├── isl_aff_out_of_bounds.ll │ ├── isl_trip_count_01.ll │ ├── isl_trip_count_02.ll │ ├── isl_trip_count_03.ll │ ├── isl_trip_count_multiple_exiting_blocks.ll │ ├── licm_load.ll │ ├── licm_potential_store.ll │ ├── licm_reduction.ll │ ├── licm_reduction_nested.ll │ ├── licm_store.ll │ ├── long-compile-time-alias-analysis.ll │ ├── long-sequence-of-error-blocks-2.ll │ ├── long-sequence-of-error-blocks.ll │ ├── loop-multiexit-succ-cond.ll │ ├── loop_affine_bound_0.ll │ ├── loop_affine_bound_1.ll │ ├── loop_affine_bound_2.ll │ ├── loop_carry.ll │ ├── many-scalar-dependences.ll │ ├── max-loop-depth.ll │ ├── memcpy-raw-source.ll │ ├── memcpy.ll │ ├── memmove.ll │ ├── memset.ll │ ├── memset_null.ll │ ├── mismatching-array-dimensions.ll │ ├── mod_ref_access_pointee_arguments.ll │ ├── mod_ref_read_pointee_arguments.ll │ ├── mod_ref_read_pointer.ll │ ├── mod_ref_read_pointers.ll │ ├── modulo_zext_1.ll │ ├── modulo_zext_2.ll │ ├── modulo_zext_3.ll │ ├── multi-scop.ll │ ├── multidim_2d-diagonal-matrix.ll │ ├── multidim_2d_outer_parametric_offset.ll │ ├── multidim_2d_parametric_array_static_loop_bounds.ll │ ├── multidim_2d_with_modref_call.ll │ ├── multidim_2d_with_modref_call_2.ll │ ├── multidim_3d_parametric_array_static_loop_bounds.ll │ ├── multidim_fixedsize_different_dimensionality.ll │ ├── multidim_fixedsize_multi_offset.ll │ ├── multidim_fold_constant_dim.ll │ ├── multidim_fold_constant_dim_zero.ll │ ├── multidim_fortran_2d.ll │ ├── multidim_fortran_2d_params.ll │ ├── multidim_fortran_2d_with_modref_call.ll │ ├── multidim_fortran_srem.ll │ ├── multidim_gep_pointercast.ll │ ├── multidim_gep_pointercast2.ll │ ├── multidim_invalid_dimension.ll │ ├── multidim_ivs_and_integer_offsets_3d.ll │ ├── multidim_ivs_and_parameteric_offsets_3d.ll │ ├── multidim_many_references.ll │ ├── multidim_nested_start_integer.ll │ ├── multidim_nested_start_share_parameter.ll │ ├── multidim_only_ivs_2d.ll │ ├── multidim_only_ivs_3d.ll │ ├── multidim_only_ivs_3d_cast.ll │ ├── multidim_only_ivs_3d_reverse.ll │ ├── multidim_param_in_subscript-2.ll │ ├── multidim_param_in_subscript.ll │ ├── multidim_parameter_addrec_product.ll │ ├── multidim_single_and_multidim_array.ll │ ├── multidim_srem.ll │ ├── multidim_with_bitcast.ll │ ├── multiple-binary-or-conditions.ll │ ├── multiple-types-access-offset-not-dividable-by-element-size.ll │ ├── multiple-types-non-affine-2.ll │ ├── multiple-types-non-affine.ll │ ├── multiple-types-non-power-of-two-2.ll │ ├── multiple-types-non-power-of-two.ll │ ├── multiple-types-two-dimensional-2.ll │ ├── multiple-types-two-dimensional.ll │ ├── multiple-types.ll │ ├── multiple_exiting_blocks.ll │ ├── multiple_exiting_blocks_two_loop.ll │ ├── multiple_latch_blocks.ll │ ├── nested-loops.ll │ ├── no-scalar-deps-in-non-affine-subregion.ll │ ├── non-affine-region-phi.ll │ ├── non-affine-region-with-loop-2.ll │ ├── non-affine-region-with-loop.ll │ ├── non-precise-inv-load-1.ll │ ├── non-precise-inv-load-2.ll │ ├── non-precise-inv-load-3.ll │ ├── non-precise-inv-load-4.ll │ ├── non-precise-inv-load-5.ll │ ├── non-precise-inv-load-6.ll │ ├── non-pure-function-call.ll │ ├── non-pure-function-calls-causes-dead-blocks.ll │ ├── non-pure-function-calls.ll │ ├── non_affine_access.ll │ ├── non_affine_region_1.ll │ ├── non_affine_region_2.ll │ ├── non_affine_region_3.ll │ ├── non_affine_region_4.ll │ ├── nonaffine-buildMemoryAccess.ll │ ├── not-a-reduction.ll │ ├── opaque-struct.ll │ ├── out-of-scop-use-in-region-entry-phi-node-nonaffine-subregion.ll │ ├── out-of-scop-use-in-region-entry-phi-node.ll │ ├── parameter-constant-division.ll │ ├── parameter_in_dead_statement.ll │ ├── parameter_product.ll │ ├── parameter_with_constant_factor_in_add.ll │ ├── partially_invariant_load_1.ll │ ├── partially_invariant_load_2.ll │ ├── phi-in-non-affine-region.ll │ ├── phi_after_error_block.ll │ ├── phi_condition_modeling_1.ll │ ├── phi_condition_modeling_2.ll │ ├── phi_conditional_simple_1.ll │ ├── phi_loop_carried_float.ll │ ├── phi_not_grouped_at_top.ll │ ├── phi_scalar_simple_1.ll │ ├── phi_scalar_simple_2.ll │ ├── phi_with_invoke_edge.ll │ ├── pointer-comparison-no-nsw.ll │ ├── pointer-comparison.ll │ ├── pointer-type-expressions.ll │ ├── pointer-used-as-base-pointer-and-scalar-read.ll │ ├── polly-timeout-parameter-bounds.ll │ ├── pr38218.ll │ ├── preserve-equiv-class-order-in-basic_block.ll │ ├── process_added_dimensions.ll │ ├── pwaff-complexity-bailout.ll │ ├── ranged_parameter.ll │ ├── ranged_parameter_2.ll │ ├── ranged_parameter_wrap.ll │ ├── ranged_parameter_wrap_2.ll │ ├── read-only-scalar-used-in-phi-2.ll │ ├── read-only-scalar-used-in-phi.ll │ ├── read-only-scalars.ll │ ├── read-only-statements.ll │ ├── reduction_alternating_base.ll │ ├── reduction_chain_partially_outside_the_scop.ll │ ├── reduction_disabled_multiplicative.ll │ ├── reduction_escaping_intermediate.ll │ ├── reduction_escaping_intermediate_2.ll │ ├── reduction_invalid_different_operators.ll │ ├── reduction_invalid_overlapping_accesses.ll │ ├── reduction_multiple_loops_array_sum.ll │ ├── reduction_multiple_loops_array_sum_1.ll │ ├── reduction_multiple_simple_binary.ll │ ├── reduction_non_overlapping_chains.ll │ ├── reduction_only_reduction_like_access.ll │ ├── reduction_simple_fp.ll │ ├── reduction_simple_w_constant.ll │ ├── reduction_simple_w_iv.ll │ ├── reduction_two_identical_reads.ll │ ├── redundant_parameter_constraint.ll │ ├── region-with-instructions.ll │ ├── remarks.ll │ ├── required-invariant-loop-bounds.ll │ ├── restriction_in_dead_block.ll │ ├── run-time-check-many-array-disjuncts.ll │ ├── run-time-check-many-parameters.ll │ ├── run-time-check-many-piecewise-aliasing.ll │ ├── run-time-check-read-only-arrays.ll │ ├── same-base-address-scalar-and-array.ll │ ├── scalar.ll │ ├── scalar_dependence_cond_br.ll │ ├── scalar_to_array.ll │ ├── scev-div-with-evaluatable-divisor.ll │ ├── scev-invalidated.ll │ ├── schedule-const-post-dominator-walk-2.ll │ ├── schedule-const-post-dominator-walk.ll │ ├── schedule-constuction-endless-loop1.ll │ ├── schedule-constuction-endless-loop2.ll │ ├── schedule-incorrectly-contructed-in-case-of-infinite-loop.ll │ ├── scop-affine-parameter-ordering.ll │ ├── sign_wrapped_set.ll │ ├── simple_loop_1.ll │ ├── simple_loop_2.ll │ ├── simple_loop_unsigned.ll │ ├── simple_loop_unsigned_2.ll │ ├── simple_loop_unsigned_3.ll │ ├── simple_nonaffine_loop_not.ll │ ├── smax.ll │ ├── statistics.ll │ ├── stmt_split_exit_of_region_stmt.ll │ ├── stmt_split_no_after_split.ll │ ├── stmt_split_no_dependence.ll │ ├── stmt_split_on_store.ll │ ├── stmt_split_on_synthesizable.ll │ ├── stmt_split_phi_in_beginning_bb.ll │ ├── stmt_split_phi_in_stmt.ll │ ├── stmt_split_scalar_dependence.ll │ ├── stmt_split_within_loop.ll │ ├── stmt_with_read_but_without_sideffect.ll │ ├── switch-1.ll │ ├── switch-2.ll │ ├── switch-3.ll │ ├── switch-4.ll │ ├── switch-5.ll │ ├── switch-6.ll │ ├── switch-7.ll │ ├── tempscop-printing.ll │ ├── test-wrapping-in-condition.ll │ ├── truncate-1.ll │ ├── truncate-2.ll │ ├── truncate-3.ll │ ├── two-loops-one-infinite.ll │ ├── two-loops-right-after-each-other.ll │ ├── undef_in_cond.ll │ ├── unnamed_nonaffine.ll │ ├── unnamed_stmts.ll │ ├── unpredictable_nonscop_loop.ll │ ├── unprofitable_scalar-accs.ll │ ├── unsigned-condition.ll │ ├── unsigned-division-1.ll │ ├── unsigned-division-2.ll │ ├── unsigned-division-3.ll │ ├── unsigned-division-4.ll │ ├── unsigned-division-5.ll │ ├── unsigned_wrap_uge.ll │ ├── unsigned_wrap_ugt.ll │ ├── unsigned_wrap_ule.ll │ ├── unsigned_wrap_ult.ll │ ├── user_context.ll │ ├── user_provided_assumptions-in-bb-signed-conditional.ll │ ├── user_provided_assumptions-in-bb-signed.ll │ ├── user_provided_assumptions-in-bb-unsigned.ll │ ├── user_provided_assumptions.ll │ ├── user_provided_assumptions_2.ll │ ├── user_provided_assumptions_3.ll │ ├── user_provided_non_dominating_assumptions.ll │ ├── variant_base_pointer.ll │ ├── variant_load_empty_domain.ll │ ├── wraping_signed_expr_0.ll │ ├── wraping_signed_expr_1.ll │ ├── wraping_signed_expr_2.ll │ ├── wraping_signed_expr_3.ll │ ├── wraping_signed_expr_4.ll │ ├── wraping_signed_expr_5.ll │ ├── wraping_signed_expr_6.ll │ ├── wraping_signed_expr_7.ll │ ├── wraping_signed_expr_slow_1.ll │ ├── wraping_signed_expr_slow_2.ll │ ├── zero_ext_of_truncate.ll │ ├── zero_ext_of_truncate_2.ll │ └── zero_ext_space_mismatch.ll ├── ScopInliner │ ├── ignore-declares.ll │ ├── invariant-load-func.ll │ └── simple-inline-loop.ll ├── Simplify │ ├── coalesce_3partials.ll │ ├── coalesce_3partials___%for---%return.jscop │ ├── coalesce_3partials___%for---%return.jscop.transformed │ ├── coalesce_disjointelements.ll │ ├── coalesce_disjointelements___%for---%return.jscop │ ├── coalesce_disjointelements___%for---%return.jscop.transformed │ ├── coalesce_overlapping.ll │ ├── coalesce_overlapping___%for---%return.jscop │ ├── coalesce_overlapping___%for---%return.jscop.transformed │ ├── coalesce_partial.ll │ ├── coalesce_partial___%for---%return.jscop │ ├── coalesce_partial___%for---%return.jscop.transformed │ ├── dead_access_load.ll │ ├── dead_access_phi.ll │ ├── dead_access_value.ll │ ├── dead_instruction.ll │ ├── emptyaccessdomain.ll │ ├── emptyaccessdomain___%for---%return.jscop │ ├── emptyaccessdomain___%for---%return.jscop.transformed │ ├── exit_phi_accesses-2.ll │ ├── gemm.ll │ ├── gemm___%bb3---%bb28.jscop │ ├── gemm___%bb3---%bb28.jscop.transformed │ ├── nocoalesce_differentvalues.ll │ ├── nocoalesce_differentvalues___%for---%return.jscop │ ├── nocoalesce_differentvalues___%for---%return.jscop.transformed │ ├── nocoalesce_elementmismatch.ll │ ├── nocoalesce_elementmismatch___%for---%return.jscop │ ├── nocoalesce_elementmismatch___%for---%return.jscop.transformed │ ├── nocoalesce_readbetween.ll │ ├── nocoalesce_readbetween___%for---%return.jscop │ ├── nocoalesce_readbetween___%for---%return.jscop.transformed │ ├── nocoalesce_writebetween.ll │ ├── nocoalesce_writebetween___%for---%return.jscop │ ├── nocoalesce_writebetween___%for---%return.jscop.transformed │ ├── notdead_region_exitphi.ll │ ├── notdead_region_innerphi.ll │ ├── notredundant_region_loop.ll │ ├── notredundant_region_loop___%for---%return.jscop │ ├── notredundant_region_loop___%for---%return.jscop.transformed │ ├── notredundant_region_middle.ll │ ├── notredundant_synthesizable_unknownit.ll │ ├── out-of-scop-use-in-region-entry-phi-node.ll │ ├── overwritten.ll │ ├── overwritten_3phi.ll │ ├── overwritten_3phi___%for---%return.jscop │ ├── overwritten_3phi___%for---%return.jscop.transformed │ ├── overwritten_3store.ll │ ├── overwritten_implicit_and_explicit.ll │ ├── overwritten_implicit_and_explicit___%for---%return.jscop │ ├── overwritten_implicit_and_explicit___%for---%return.jscop.transformed │ ├── overwritten_loadbetween.ll │ ├── overwritten_scalar.ll │ ├── overwritten_scalar___%for---%return.jscop │ ├── overwritten_scalar___%for---%return.jscop.transformed │ ├── pass_existence.ll │ ├── phi_in_regionstmt.ll │ ├── pr33323.ll │ ├── pr33323___%for.body98---%for.cond87.loopexit.jscop │ ├── pr33323___%for.body98---%for.cond87.loopexit.jscop.transformed │ ├── redundant.ll │ ├── redundant_differentindex.ll │ ├── redundant_partialwrite.ll │ ├── redundant_partialwrite___%for---%return.jscop │ ├── redundant_partialwrite___%for---%return.jscop.transformed │ ├── redundant_region.ll │ ├── redundant_region___%for---%return.jscop │ ├── redundant_region___%for---%return.jscop.transformed │ ├── redundant_region_scalar.ll │ ├── redundant_region_scalar___%for---%return.jscop │ ├── redundant_region_scalar___%for---%return.jscop.transformed │ ├── redundant_scalarwrite.ll │ ├── redundant_scalarwrite___%for---%return.jscop │ ├── redundant_scalarwrite___%for---%return.jscop.transformed │ ├── redundant_storebetween.ll │ ├── scalability1.ll │ ├── scalability2.ll │ ├── sweep_mapped_phi.ll │ ├── sweep_mapped_phi___%for---%return.jscop │ ├── sweep_mapped_phi___%for---%return.jscop.transformed │ ├── sweep_mapped_value.ll │ ├── sweep_mapped_value___%for---%return.jscop │ ├── sweep_mapped_value___%for---%return.jscop.transformed │ └── ununsed_read_in_region_entry.ll ├── Support │ └── Plugins.ll ├── Unit │ ├── lit.cfg │ └── lit.site.cfg.in ├── UnitIsl │ ├── isl_test.sh │ ├── lit.cfg │ └── lit.site.cfg.in ├── create_ll.sh ├── lit.cfg ├── lit.site.cfg.in ├── polly.ll └── update_check.py ├── tools ├── CMakeLists.txt └── GPURuntime │ ├── CMakeLists.txt │ ├── GPUJIT.c │ ├── GPUJIT.h │ └── LICENSE.TXT ├── unittests ├── CMakeLists.txt ├── DeLICM │ ├── CMakeLists.txt │ └── DeLICMTest.cpp ├── Flatten │ ├── CMakeLists.txt │ └── FlattenTest.cpp ├── Isl │ ├── CMakeLists.txt │ └── IslTest.cpp ├── ScheduleOptimizer │ ├── CMakeLists.txt │ └── ScheduleOptimizerTest.cpp ├── ScopPassManager │ ├── CMakeLists.txt │ └── PassManagerTest.cpp └── Support │ ├── CMakeLists.txt │ └── ISLTools.cpp ├── utils ├── argparse.py ├── jscop2cloog.py └── pyscop │ ├── isl.py │ ├── jscop2iscc.py │ └── pyscop.py └── www ├── .htaccess ├── bugs.html ├── changelog.html ├── content.css ├── contributors.html ├── documentation.html ├── documentation ├── architecture.html ├── gpgpucodegen.html └── passes.html ├── favicon.ico ├── get_started.html ├── google1242f26b67e33344.html ├── hangouts.html ├── images ├── GEMM_double.png ├── LLVM-Passes.xml ├── PollyArchitecture.xml ├── architecture.png ├── header-background.png ├── iit-madras.png ├── osu.png ├── performance │ ├── parallel-large.png │ ├── parallel-small.png │ ├── sequential-large.png │ └── sequential-small.png ├── pollylabs.png ├── sys-uni.png ├── uni-passau.png └── video-summit-2011.png ├── index.html ├── menu.css ├── menu.html.incl ├── performance.html ├── phonecall.html ├── polly.sh ├── projects.html ├── publications.html ├── publications ├── grosser-diploma-thesis.pdf ├── grosser-impact-2011-slides.pdf ├── grosser-impact-2011.pdf ├── kernelgen-ncar-2012-slides.pdf ├── kernelgen-pavt-2012-slides.pdf └── raghesh-a-masters-thesis.pdf ├── todo.html └── video-js ├── video-js.css └── video.js /.arcconfig: -------------------------------------------------------------------------------- 1 | { 2 | "repository.callsign" : "PLO", 3 | "conduit_uri" : "https://reviews.llvm.org/" 4 | } 5 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text eol=lf 3 | *.png -text 4 | *.pdf -text 5 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | test/lit.site.cfg 2 | lib/External/isl/doc/manual.pdf 3 | 00* 4 | -------------------------------------------------------------------------------- /docs/experiments/matmul/scops.init_array.dot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/experiments/matmul/scops.init_array.dot.png -------------------------------------------------------------------------------- /docs/experiments/matmul/scops.main.dot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/experiments/matmul/scops.main.dot.png -------------------------------------------------------------------------------- /docs/experiments/matmul/scops.print_array.dot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/experiments/matmul/scops.print_array.dot.png -------------------------------------------------------------------------------- /docs/experiments/matmul/scopsonly.init_array.dot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/experiments/matmul/scopsonly.init_array.dot.png -------------------------------------------------------------------------------- /docs/experiments/matmul/scopsonly.main.dot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/experiments/matmul/scopsonly.main.dot.png -------------------------------------------------------------------------------- /docs/experiments/matmul/scopsonly.print_array.dot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/experiments/matmul/scopsonly.print_array.dot.png -------------------------------------------------------------------------------- /docs/images/GEMM_double.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/GEMM_double.png -------------------------------------------------------------------------------- /docs/images/LLVM-Passes-all.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/LLVM-Passes-all.pdf -------------------------------------------------------------------------------- /docs/images/LLVM-Passes-all.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/LLVM-Passes-all.png -------------------------------------------------------------------------------- /docs/images/LLVM-Passes-early.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/LLVM-Passes-early.pdf -------------------------------------------------------------------------------- /docs/images/LLVM-Passes-early.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/LLVM-Passes-early.png -------------------------------------------------------------------------------- /docs/images/LLVM-Passes-late.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/LLVM-Passes-late.pdf -------------------------------------------------------------------------------- /docs/images/LLVM-Passes-late.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/LLVM-Passes-late.png -------------------------------------------------------------------------------- /docs/images/LLVM-Passes-only.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/LLVM-Passes-only.pdf -------------------------------------------------------------------------------- /docs/images/LLVM-Passes-only.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/LLVM-Passes-only.png -------------------------------------------------------------------------------- /docs/images/architecture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/docs/images/architecture.png -------------------------------------------------------------------------------- /lib/External/isl/GIT_HEAD_ID: -------------------------------------------------------------------------------- 1 | isl-0.20-65-gb822a210 2 | -------------------------------------------------------------------------------- /lib/External/isl/all.c: -------------------------------------------------------------------------------- 1 | #include "all.h" 2 | -------------------------------------------------------------------------------- /lib/External/isl/all.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | -------------------------------------------------------------------------------- /lib/External/isl/bset_from_bmap.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* Return the basic set that was treated as the basic map "bmap". 4 | */ 5 | static __isl_give isl_basic_set *bset_from_bmap(__isl_take isl_basic_map *bmap) 6 | { 7 | return (isl_basic_set *) bmap; 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/bset_to_bmap.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* Treat "bset" as a basic map. 4 | * Internally, isl_basic_set is defined to isl_basic_map, so in practice, 5 | * this function performs a redundant cast. 6 | */ 7 | static __isl_give isl_basic_map *bset_to_bmap(__isl_take isl_basic_set *bset) 8 | { 9 | return (isl_basic_map *) bset; 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl/cpp/cpp-checked-conversion.h.bot: -------------------------------------------------------------------------------- 1 | 2 | #endif /* ISL_CPP_CHECKED_CONVERSION */ 3 | -------------------------------------------------------------------------------- /lib/External/isl/cpp/cpp-checked.h.bot: -------------------------------------------------------------------------------- 1 | 2 | #endif /* ISL_CPP_CHECKED */ 3 | -------------------------------------------------------------------------------- /lib/External/isl/cpp/cpp.h.bot: -------------------------------------------------------------------------------- 1 | 2 | #endif /* ISL_CPP */ 3 | -------------------------------------------------------------------------------- /lib/External/isl/doc/mypod2latex: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | 3 | use strict; 4 | use Pod::LaTeX; 5 | 6 | my ($in, $out) = @ARGV; 7 | 8 | my $parser = new Pod::LaTeX( 9 | AddPreamble => 0, 10 | AddPostamble => 0, 11 | LevelNoNum => 5, 12 | ); 13 | 14 | $parser->parse_from_file($in, $out); 15 | -------------------------------------------------------------------------------- /lib/External/isl/imath_wrap/gmp_compat.c: -------------------------------------------------------------------------------- 1 | #include "wrap.h" 2 | #include "../imath/gmp_compat.c" 3 | -------------------------------------------------------------------------------- /lib/External/isl/imath_wrap/gmp_compat.h: -------------------------------------------------------------------------------- 1 | #include "wrap.h" 2 | #include "../imath/gmp_compat.h" 3 | -------------------------------------------------------------------------------- /lib/External/isl/imath_wrap/imath.c: -------------------------------------------------------------------------------- 1 | #include "wrap.h" 2 | #include "../imath/imath.c" 3 | -------------------------------------------------------------------------------- /lib/External/isl/imath_wrap/imath.h: -------------------------------------------------------------------------------- 1 | #include "wrap.h" 2 | #include "../imath/imath.h" 3 | -------------------------------------------------------------------------------- /lib/External/isl/imath_wrap/imrat.c: -------------------------------------------------------------------------------- 1 | #include "wrap.h" 2 | #include "../imath/imrat.c" 3 | -------------------------------------------------------------------------------- /lib/External/isl/imath_wrap/imrat.h: -------------------------------------------------------------------------------- 1 | #include "wrap.h" 2 | #include "../imath/imrat.h" 3 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/id_type.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_ID_TYPE_H 2 | #define ISL_ID_TYPE_H 3 | 4 | #include 5 | 6 | #if defined(__cplusplus) 7 | extern "C" { 8 | #endif 9 | 10 | struct isl_id; 11 | typedef struct isl_id isl_id; 12 | 13 | ISL_DECLARE_LIST_TYPE(id) 14 | 15 | #if defined(__cplusplus) 16 | } 17 | #endif 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/maybe.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_MAYBE_H 2 | #define ISL_MAYBE_H 3 | 4 | #define ISL_xMAYBE(TYPE) isl_maybe_ ## TYPE 5 | #define ISL_MAYBE(TYPE) ISL_xMAYBE(TYPE) 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/maybe_ast_expr.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_MAYBE_AST_EXPR_H 2 | #define ISL_MAYBE_AST_EXPR_H 3 | 4 | #define ISL_TYPE isl_ast_expr 5 | #include 6 | #undef ISL_TYPE 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/maybe_basic_set.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_MAYBE_BASIC_SET_H 2 | #define ISL_MAYBE_BASIC_SET_H 3 | 4 | #define ISL_TYPE isl_basic_set 5 | #include 6 | #undef ISL_TYPE 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/maybe_id.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_MAYBE_ID_H 2 | #define ISL_MAYBE_ID_H 3 | 4 | #define ISL_TYPE isl_id 5 | #include 6 | #undef ISL_TYPE 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/maybe_pw_aff.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_MAYBE_PW_AFF_H 2 | #define ISL_MAYBE_PW_AFF_H 3 | 4 | #define ISL_TYPE isl_pw_aff 5 | #include 6 | #undef ISL_TYPE 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/printer_type.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_PRINTER_TYPE_H 2 | #define ISL_PRINTER_TYPE_H 3 | 4 | #if defined(__cplusplus) 5 | extern "C" { 6 | #endif 7 | 8 | struct isl_printer; 9 | typedef struct isl_printer isl_printer; 10 | 11 | #if defined(__cplusplus) 12 | } 13 | #endif 14 | 15 | #endif 16 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/set_type.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_SET_TYPE_H 2 | #define ISL_SET_TYPE_H 3 | 4 | #include 5 | 6 | #endif 7 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/union_set_type.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_UNION_SET_TYPE_H 2 | #define ISL_UNION_SET_TYPE_H 3 | 4 | #include 5 | 6 | #endif 7 | -------------------------------------------------------------------------------- /lib/External/isl/include/isl/version.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_VERSION_H 2 | #define ISL_VERSION_H 3 | 4 | #if defined(__cplusplus) 5 | extern "C" { 6 | #endif 7 | 8 | const char *isl_version(void); 9 | 10 | #if defined(__cplusplus) 11 | } 12 | #endif 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /lib/External/isl/interface/extract_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | bool has_annotation(clang::Decl *decl, const char *name); 4 | -------------------------------------------------------------------------------- /lib/External/isl/isl_bernstein.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | isl_stat isl_qpolynomial_bound_on_domain_bernstein( 4 | __isl_take isl_basic_set *bset, __isl_take isl_qpolynomial *poly, 5 | struct isl_bound *bound); 6 | -------------------------------------------------------------------------------- /lib/External/isl/isl_hash_private.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_HASH_PRIVATE 2 | #define ISL_HASH_PRIVATE 3 | 4 | #include 5 | 6 | extern struct isl_hash_table_entry *isl_hash_table_entry_none; 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /lib/External/isl/isl_ilp_private.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_ILP_PRIVATE_H 2 | #define ISL_ILP_PRIVATE_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | enum isl_lp_result isl_basic_set_solve_ilp(__isl_keep isl_basic_set *bset, 9 | int max, isl_int *f, isl_int *opt, __isl_give isl_vec **sol_p); 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /lib/External/isl/isl_maybe_map.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_MAYBE_MAP_H 2 | #define ISL_MAYBE_MAP_H 3 | 4 | #include 5 | 6 | #define ISL_TYPE isl_map 7 | #include 8 | #undef ISL_TYPE 9 | 10 | #endif 11 | -------------------------------------------------------------------------------- /lib/External/isl/isl_multi_align_set.c: -------------------------------------------------------------------------------- 1 | #define ALIGN_DOMBASE set 2 | #define ALIGN_DOM isl_set 3 | 4 | #include 5 | 6 | #undef ALIGN_DOMBASE 7 | #undef ALIGN_DOM 8 | -------------------------------------------------------------------------------- /lib/External/isl/isl_multi_align_union_set.c: -------------------------------------------------------------------------------- 1 | #define ALIGN_DOMBASE union_set 2 | #define ALIGN_DOM isl_union_set 3 | 4 | #include 5 | 6 | #undef ALIGN_DOMBASE 7 | #undef ALIGN_DOM 8 | -------------------------------------------------------------------------------- /lib/External/isl/isl_multi_apply_set.c: -------------------------------------------------------------------------------- 1 | #define APPLY_DOMBASE set 2 | #define APPLY_DOM isl_set 3 | 4 | #include 5 | 6 | #undef APPLY_DOMBASE 7 | #undef APPLY_DOM 8 | -------------------------------------------------------------------------------- /lib/External/isl/isl_multi_apply_union_set.c: -------------------------------------------------------------------------------- 1 | #define APPLY_DOMBASE union_set 2 | #define APPLY_DOM isl_union_set 3 | 4 | #include 5 | 6 | #undef APPLY_DOMBASE 7 | #undef APPLY_DOM 8 | -------------------------------------------------------------------------------- /lib/External/isl/isl_multi_macro.h: -------------------------------------------------------------------------------- 1 | #define xCAT(A,B) A ## B 2 | #define CAT(A,B) xCAT(A,B) 3 | #undef EL 4 | #define EL CAT(isl_,BASE) 5 | #define xFN(TYPE,NAME) TYPE ## _ ## NAME 6 | #define FN(TYPE,NAME) xFN(TYPE,NAME) 7 | #define xMULTI(BASE) isl_multi_ ## BASE 8 | #define MULTI(BASE) xMULTI(BASE) 9 | #undef DOM 10 | #define DOM CAT(isl_,DOMBASE) 11 | -------------------------------------------------------------------------------- /lib/External/isl/isl_pw_macro.h: -------------------------------------------------------------------------------- 1 | #define xFN(TYPE,NAME) TYPE ## _ ## NAME 2 | #define FN(TYPE,NAME) xFN(TYPE,NAME) 3 | #define xS(TYPE,NAME) struct TYPE ## _ ## NAME 4 | #define S(TYPE,NAME) xS(TYPE,NAME) 5 | -------------------------------------------------------------------------------- /lib/External/isl/isl_pw_templ.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | __isl_keep isl_space *FN(PW,peek_space)(__isl_keep PW *pw); 6 | -------------------------------------------------------------------------------- /lib/External/isl/isl_range.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | isl_stat isl_qpolynomial_bound_on_domain_range(__isl_take isl_basic_set *bset, 4 | __isl_take isl_qpolynomial *poly, struct isl_bound *bound); 5 | __isl_give isl_qpolynomial *isl_qpolynomial_terms_of_sign( 6 | __isl_keep isl_qpolynomial *poly, int *signs, int sign); 7 | -------------------------------------------------------------------------------- /lib/External/isl/isl_sort.h: -------------------------------------------------------------------------------- 1 | #ifndef ISL_SORT_H 2 | #define ISL_SORT_H 3 | 4 | #include 5 | 6 | int isl_sort(void *const pbase, size_t total_elems, size_t size, 7 | int (*cmp)(const void *, const void *, void *arg), void *arg); 8 | 9 | #endif 10 | -------------------------------------------------------------------------------- /lib/External/isl/isl_srcdir.c.in: -------------------------------------------------------------------------------- 1 | static const char *srcdir = "@srcdir@"; 2 | -------------------------------------------------------------------------------- /lib/External/isl/isl_union_macro.h: -------------------------------------------------------------------------------- 1 | #define xCAT(A,B) A ## B 2 | #define CAT(A,B) xCAT(A,B) 3 | #undef PART 4 | #define PART CAT(isl_,BASE) 5 | #undef UNION 6 | #define UNION CAT(isl_union_,BASE) 7 | #define xFN(TYPE,NAME) TYPE ## _ ## NAME 8 | #define FN(TYPE,NAME) xFN(TYPE,NAME) 9 | #define xS(TYPE,NAME) struct TYPE ## _ ## NAME 10 | #define S(TYPE,NAME) xS(TYPE,NAME) 11 | -------------------------------------------------------------------------------- /lib/External/isl/isl_version.c: -------------------------------------------------------------------------------- 1 | #include "isl_config.h" 2 | #include "gitversion.h" 3 | 4 | const char *isl_version(void) 5 | { 6 | return GIT_HEAD_ID 7 | #ifdef USE_GMP_FOR_MP 8 | "-GMP" 9 | #endif 10 | #ifdef USE_IMATH_FOR_MP 11 | "-IMath" 12 | #ifdef USE_SMALL_INT_OPT 13 | "-32" 14 | #endif 15 | #endif 16 | "\n"; 17 | } 18 | -------------------------------------------------------------------------------- /lib/External/isl/set_from_map.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* Return the set that was treated as the map "map". 4 | */ 5 | static __isl_give isl_set *set_from_map(__isl_take isl_map *map) 6 | { 7 | return (isl_set *) map; 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/set_list_from_map_list_inl.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* Return the set list that was treated as the map list "list". 4 | */ 5 | static __isl_give isl_set_list *set_list_from_map_list( 6 | __isl_take isl_map_list *list) 7 | { 8 | return (isl_set_list *) list; 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/set_to_map.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* Treat "set" as a map. 4 | * Internally, isl_set is defined to isl_map, so in practice, 5 | * this function performs a redundant cast. 6 | */ 7 | static __isl_give isl_map *set_to_map(__isl_take isl_set *set) 8 | { 9 | return (isl_map *) set; 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/affine.polylib: -------------------------------------------------------------------------------- 1 | # the affine hull of {[a,b] : a=b && 1 <= a <= 163} ... 2 | 3 4 3 | 0 1 -1 0 4 | 1 1 0 -1 5 | 1 -1 0 163 6 | 7 | # ... is {[a,b] : a=b} (and not {[In_1,In_2]}, as Omega 1.2 claims) 8 | 1 4 9 | 0 1 -1 0 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/affine2.polylib: -------------------------------------------------------------------------------- 1 | 5 5 2 | 1 -2 0 1 0 3 | 1 2 0 -1 1 4 | 1 0 -2 1 0 5 | 1 0 2 -1 1 6 | 1 0 0 1 -1 7 | 8 | 1 5 9 | 0 1 -1 0 0 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/affine3.polylib: -------------------------------------------------------------------------------- 1 | 3 4 2 | 1 1 0 0 3 | 1 -7 4 2 4 | 1 5 -4 2 5 | 6 | 1 4 7 | 0 3 -2 0 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/application.omega: -------------------------------------------------------------------------------- 1 | {[x]} 2 | {[x] -> [y] : y = 2x} 3 | {[y]: Exists ( alpha : 2alpha = y)} 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/application2.omega: -------------------------------------------------------------------------------- 1 | {[x] : x >= 0 && x <= 20 } 2 | {[x] -> [y] : y = 2x} 3 | {[y]: Exists ( alpha : 2alpha = y && 0 <= y && y <= 40)} 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/basicLinear.pwqp: -------------------------------------------------------------------------------- 1 | [P, Q] -> { [n, m] -> n : n >= 1 and m >= n and m <= P and m <= Q } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/basicLinear2.pwqp: -------------------------------------------------------------------------------- 1 | [P, Q] -> { [n, m] -> n : n >= 1 and m >= n and m <= P and n >= -1 + Q } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/basicTest.pwqp: -------------------------------------------------------------------------------- 1 | [p] -> { [n, m] -> (n + n^2) : n >= 1 and m >= n and m <= p } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/basicTestParameterPosNeg.pwqp: -------------------------------------------------------------------------------- 1 | [p] -> { [n, m] -> (n + n^3) : n >= -1 and m >= n and m <= p } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/boulet.pip: -------------------------------------------------------------------------------- 1 | 0 3 2 | 3 | -1 4 | 5 | 5 6 6 | 1 1 -1 2 0 0 7 | 1 0 1 1 4 20 8 | 1 0 -1 -1 0 0 9 | 1 0 1 -1 2 10 10 | 1 0 -1 1 2 10 11 | 12 | Urs_parms 13 | Urs_unknowns 14 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/cg1.pip: -------------------------------------------------------------------------------- 1 | 2 4 2 | 1 1 0 -1 3 | 1 -1 1 0 4 | 5 | -1 6 | 7 | 8 7 8 | 1 0 1 0 -1 0 0 9 | 1 0 -1 0 1 0 0 10 | 1 1 0 0 0 -1 0 11 | 1 -1 0 0 0 1 0 12 | 1 0 1 0 0 0 -1 13 | 1 0 -1 0 0 1 0 14 | 1 0 -1 1 0 0 -1 15 | 1 0 0 -1 0 1 0 16 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/atomic.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 10; c0 += 1) { 2 | if (c0 <= 9) 3 | a(c0); 4 | if (c0 >= 1) 5 | b(c0 - 1); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/atomic.in: -------------------------------------------------------------------------------- 1 | { a[i] -> [i, 0] : 0 <= i < 10; b[i] -> [i+1, 1] : 0 <= i < 10 } 2 | { : } 3 | { [i, d] -> atomic[x] } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/atomic.st: -------------------------------------------------------------------------------- 1 | domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }" 2 | child: 3 | schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]" 4 | options: "{ atomic[x] }" 5 | child: 6 | sequence: 7 | - filter: "{ a[i] }" 8 | - filter: "{ b[i] }" 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/atomic2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = ((b0 + 32767) % 32768) + 1; c0 <= 65534; c0 += 32768) 2 | A(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/atomic2.in: -------------------------------------------------------------------------------- 1 | # Check that isl properly handles atomic domains that are unions. 2 | [nn, b0] -> { A[a] -> [a, 0, b0] : exists (e0 = [(b0 - a)/32768]: 32768e0 = b0 - a and a >= 1 and b0 >= 0 and b0 <= 32767 and a <= 65534) } 3 | [nn, b0] -> { : b0 >= 0 and b0 <= 32767 } 4 | [nn, b0] -> { [a, b, c] -> atomic[2] : c >= 1; [a, 0, c] -> atomic[2] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/atomic3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 64; c0 += 1) { 2 | if (c0 >= 63) { 3 | sync(); 4 | } else if (c0 >= 1) { 5 | sync(); 6 | } else { 7 | sync(); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/atomic3.in: -------------------------------------------------------------------------------- 1 | # Check that isl is not confused by inconsistent 2 | # separation_class and atomic options. 3 | { sync[] -> [i, 0] : 0 <= i <= 64 } 4 | { : } 5 | { [i, 0] -> separation_class[[1] -> [0]] : 1 <= i <= 62; [i, 0] -> atomic[1]} 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/atomic4.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 64; c0 += 1) 2 | sync(); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/atomic4.in: -------------------------------------------------------------------------------- 1 | # Check that isl is not confused by inconsistent separate and atomic options. 2 | { sync[] -> [i, 0] : 0 <= i <= 64 } 3 | { : } 4 | { [i, 0] -> separate[1] : 1 <= i <= 62; [i, 0] -> atomic[1] : i <= 10 or i >= 20 } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cholesky.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 3993; c0 <= 63893; c0 += 1) 2 | if (2 * c0 - 3993 * ((3 * c0 + 5990) / 5990) >= 0) 3 | for (int c4 = -c0 + 1997 * ((3 * c0 + 5990) / 5990) + 1; c4 <= 12; c4 += 1) 4 | S_3(c4, -c0 + 1997 * ((3 * c0 + 5990) / 5990), 2 * c0 - 3993 * ((3 * c0 + 5990) / 5990)); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/0D-1.c: -------------------------------------------------------------------------------- 1 | S1(); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/0D-1.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[] }" 2 | child: 3 | context: "{ [] }" 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/0D-2.c: -------------------------------------------------------------------------------- 1 | if (M >= 0) 2 | S1(); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/0D-2.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[] : M >= 0 }" 2 | child: 3 | context: "[M] -> { [] }" 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/0D-3.c: -------------------------------------------------------------------------------- 1 | S1(); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/0D-3.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[] : M >= 0 }" 2 | child: 3 | context: "[M] -> { [] : M >= 0 }" 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/1point-1.c: -------------------------------------------------------------------------------- 1 | S1(2 * M, M); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/1point-1.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[2M, M] }" 2 | child: 3 | context: "[M] -> { [] }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0, i1] -> [(i0)] }, { S1[i0, i1] -> [(i1)] }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/1point-2.c: -------------------------------------------------------------------------------- 1 | S1(2 * M, N + 2); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/1point-2.st: -------------------------------------------------------------------------------- 1 | domain: "[M, N] -> { S1[2M, 2 + N] }" 2 | child: 3 | context: "[M, N] -> { [] }" 4 | child: 5 | schedule: "[M, N] -> [{ S1[i0, i1] -> [(i0)] }, { S1[i0, i1] -> [(i1)] }]" 6 | options: "[M, N] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/README: -------------------------------------------------------------------------------- 1 | The tests in this directory have been adapted from the corresponding CLooG 2 | test cases. 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/backtrack.c: -------------------------------------------------------------------------------- 1 | S1(0); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/backtrack.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[0] }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i0] -> [(i0)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 2; c0 += 1) 2 | S1(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-1.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[i0] : i0 >= 0 and i0 <= 2 }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i0] -> [(i0)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-2.c: -------------------------------------------------------------------------------- 1 | S1(0); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-2.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[0] }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i0] -> [(i0)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= M; c0 += 1) 2 | S1(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-3.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[i0] : i0 >= 0 and i0 <= M }" 2 | child: 3 | context: "[M] -> { [] : M >= 0 }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0] -> [(i0)] }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-4.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= M + 1; c0 += 1) 2 | S1(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-4.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[i0] : i0 >= 0 and i0 <= 1 + M }" 2 | child: 3 | context: "[M] -> { [] : M >= 0 }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0] -> [(i0)] }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-5.c: -------------------------------------------------------------------------------- 1 | S1(1, floord(M + 1, 2)); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-5.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[1, i1] : 2i1 >= M and 2i1 <= 1 + M }" 2 | child: 3 | context: "[M] -> { [] }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0, i1] -> [(i0)] }, { S1[i0, i1] -> [(i1)] }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-6.c: -------------------------------------------------------------------------------- 1 | S1(-1); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/basic-bounds-6.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[-1] }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i0] -> [(i0)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/block.c: -------------------------------------------------------------------------------- 1 | { 2 | S1(); 3 | S3(0); 4 | S2(); 5 | S3(1); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/block.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[]; S3[i0] : i0 >= 0 and i0 <= 1; S2[] }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S2[] -> [(1)]; S3[i0] -> [(i0)]; S1[] -> [(0)] }]" 6 | options: "{ separate[i0] }" 7 | child: 8 | sequence: 9 | - filter: "{ S1[]; S2[] }" 10 | - filter: "{ S3[i0] }" 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/block2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 9; c0 += 1) { 2 | S1(c0, 1); 3 | S3(c0, 1); 4 | S2(c0, 1); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/block3.c: -------------------------------------------------------------------------------- 1 | { 2 | S1(); 3 | for (int c0 = 0; c0 <= 1; c0 += 1) 4 | S3(c0); 5 | S2(); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/block3.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[]; S3[i0] : i0 >= 0 and i0 <= 1; S2[] }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S2[] -> [(1)]; S3[i0] -> [(i0)]; S1[] -> [(0)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/cholesky.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 1) { 2 | S1(c0); 3 | for (int c1 = 1; c1 < c0; c1 += 1) 4 | S2(c0, c1); 5 | S3(c0); 6 | for (int c1 = c0 + 1; c1 <= n; c1 += 1) { 7 | S4(c0, c1); 8 | for (int c2 = 1; c2 < c0; c2 += 1) 9 | S5(c0, c1, c2); 10 | S6(c0, c1); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/christian.c: -------------------------------------------------------------------------------- 1 | for (int c0 = -N + 1; c0 <= N; c0 += 1) { 2 | for (int c1 = max(0, c0); c1 < min(N, N + c0); c1 += 1) 3 | S1(c1, -c0 + c1); 4 | for (int c1 = max(0, c0 - 1); c1 < min(N, N + c0 - 1); c1 += 1) 5 | S2(c1, -c0 + c1 + 1); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/constbound.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 199; c0 += 1) { 2 | for (int c1 = 50 * c0; c1 <= 50 * c0 + 24; c1 += 1) 3 | for (int c2 = 0; c2 <= c1; c2 += 1) 4 | S1(c0, c1, c2); 5 | for (int c1 = 50 * c0 + 25; c1 <= 50 * c0 + 49; c1 += 1) 6 | for (int c2 = 0; c2 <= c1; c2 += 1) 7 | S2(c0, c1, c2); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/donotsimp.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 10; c0 += 1) { 2 | for (int c1 = 1; c1 <= c0; c1 += 1) 3 | S1(c0, c1); 4 | for (int c1 = 11; c1 <= M; c1 += 1) 5 | S2(c0, c1); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/dot.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c1 = 1; c1 <= M; c1 += 1) 3 | S1(0, c1); 4 | for (int c0 = 1; c0 <= N; c0 += 1) 5 | for (int c1 = 1; c1 <= M; c1 += 1) 6 | S2(c0, c1); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/dot2.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 1; c0 <= min(M, N); c0 += 1) { 3 | S1(c0); 4 | for (int c1 = 1; c1 <= M; c1 += 1) 5 | S2(c0, c1); 6 | } 7 | for (int c0 = M + 1; c0 <= N; c0 += 1) 8 | for (int c1 = 1; c1 <= M; c1 += 1) 9 | S2(c0, c1); 10 | for (int c0 = N + 1; c0 <= M; c0 += 1) 11 | S1(c0); 12 | } 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/emploi.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 1) { 2 | S1(c0); 3 | for (int c1 = 1; c1 <= m; c1 += 1) 4 | S2(c0, c1); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/equality.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 5; c0 += 1) 2 | for (int c1 = min(4, 2 * c0); c1 <= max(4, 2 * c0); c1 += 1) { 3 | if (c1 == 2 * c0) 4 | S1(c0, 2 * c0); 5 | if (c1 == 4) 6 | S2(c0, 4); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/esced.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= m; c0 += 1) { 2 | S1(c0); 3 | for (int c1 = 1; c1 <= n; c1 += 1) 4 | S2(c0, c1); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/forwardsub-1-1-2.c: -------------------------------------------------------------------------------- 1 | { 2 | S3(1, 1); 3 | for (int c0 = 2; c0 <= M; c0 += 1) { 4 | S1(c0, 1); 5 | for (int c1 = 2; c1 < c0; c1 += 1) 6 | S2(c0, c1); 7 | S4(c0, c0); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/forwardsub-2-1-2-3.c: -------------------------------------------------------------------------------- 1 | { 2 | S3(1, 0); 3 | for (int c2 = 2; c2 <= M; c2 += 1) 4 | S1(1, 1, c2); 5 | for (int c0 = 2; c0 <= M; c0 += 1) { 6 | S4(c0, 0); 7 | for (int c2 = c0 + 1; c2 <= M; c2 += 1) 8 | S2(c0, 1, c2); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/gauss.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 < M; c0 += 1) 2 | for (int c1 = c0 + 1; c1 <= M; c1 += 1) { 3 | for (int c3 = 1; c3 < c0; c3 += 1) 4 | S1(c0, c3, c1); 5 | for (int c3 = c0 + 1; c3 <= M; c3 += 1) 6 | S2(c0, c3, c1); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/gesced3.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = M + 1; c0 <= 2 * M; c0 += 1) 3 | S1(-M + c0); 4 | for (int c0 = 2 * M + 1; c0 <= M + N; c0 += 1) { 5 | S2(-2 * M + c0); 6 | S1(-M + c0); 7 | } 8 | for (int c0 = M + N + 1; c0 <= 2 * M + N; c0 += 1) 9 | S2(-2 * M + c0); 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/gesced3.st: -------------------------------------------------------------------------------- 1 | domain: "[M, N] -> { S1[i0] : i0 >= 1 and i0 <= N; S2[i0] : i0 >= 1 and i0 <= N }" 2 | child: 3 | context: "[M, N] -> { [] : N >= M and M >= 2 }" 4 | child: 5 | schedule: "[M, N] -> [{ S2[i0] -> [(2M + i0)]; S1[i0] -> [(M + i0)] }]" 6 | options: "[M, N] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/guide.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 1; c0 <= N; c0 += 1) 3 | S1(c0); 4 | for (int c0 = N + 1; c0 <= 2 * N; c0 += 1) 5 | S2(c0); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/iftest.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 1) 2 | S1(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/iftest.st: -------------------------------------------------------------------------------- 1 | domain: "[m, n] -> { S1[i0] : (i0 >= m and i0 >= 1 and i0 <= n) or (i0 >= 1 and i0 <= n and i0 <= 2m) }" 2 | child: 3 | context: "[m, n] -> { [] }" 4 | child: 5 | schedule: "[m, n] -> [{ S1[i0] -> [(i0)] }]" 6 | options: "[m, n] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/iftest2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= N; c0 += 1) 2 | for (int c1 = 1; c1 <= M; c1 += 1) 3 | S1(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/infinite2.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 1; c0 <= N; c0 += 1) { 3 | S1(c0); 4 | for (int c1 = 1; c1 <= M; c1 += 1) 5 | S2(c0, c1); 6 | } 7 | for (int c0 = N + 1; 1; c0 += 1) 8 | S1(c0); 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/jacobi-shared.c: -------------------------------------------------------------------------------- 1 | if (((t1 + 31) % 32) + g2 >= 2 && N >= ((t1 + 31) % 32) + g2 + 2 && (h0 + 1) % 2 == 0) 2 | for (int c0 = max(((t0 + 15) % 16) + 1, ((g1 + t0 + 13) % 16) - g1 + 3); c0 <= min(32, N - g1 - 1); c0 += 16) 3 | S1(g1 + c0 - 1, -((g2 - t1 + 32) % 32) + g2 + 31); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/largeur.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= M; c0 += 1) 2 | for (int c1 = 1; c1 <= c0; c1 += 1) 3 | S1(c1, c0); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/largeur.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[i0, i1] : i0 >= 1 and i0 <= M and i1 >= i0 and i1 <= M }" 2 | child: 3 | context: "[M] -> { [] : M >= 0 }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0, i1] -> [(i1)] }, { S1[i0, i1] -> [(i0)] }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/lex.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 10; c0 += 1) { 2 | S2(c0); 3 | S1(c0); 4 | } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/lineality-1-2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= M; c0 += 1) { 2 | for (int c1 = 1; c1 < c0; c1 += 1) 3 | S1(c0, c1); 4 | S1(c0, c0); 5 | S2(c0, c0); 6 | for (int c1 = c0 + 1; c1 <= M; c1 += 1) 7 | S1(c0, c1); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/lu.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 1) { 2 | for (int c1 = 2; c1 <= n; c1 += 1) 3 | for (int c2 = 1; c2 < min(c0, c1); c2 += 1) 4 | S2(c2, c1, c0); 5 | for (int c3 = c0 + 1; c3 <= n; c3 += 1) 6 | S1(c0, c3); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/lu2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 1) { 2 | for (int c1 = 2; c1 <= n; c1 += 1) 3 | for (int c2 = 1; c2 < min(c0, c1); c2 += 1) 4 | S2(c0, c1, c2, c1, c0); 5 | for (int c3 = c0 + 1; c3 <= n; c3 += 1) 6 | S1(c0, n, c0, c3); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/lux.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= M; c0 += 1) { 2 | for (int c1 = 1; c1 < c0; c1 += 1) 3 | for (int c2 = c1 + 1; c2 <= M; c2 += 1) 4 | S2(c0, c1, c2, c2, c0); 5 | for (int c3 = c0 + 1; c3 <= M; c3 += 1) 6 | S1(c0, c0, M, c3); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/merge.c: -------------------------------------------------------------------------------- 1 | { 2 | S1(0); 3 | for (int c0 = 0; c0 <= 10; c0 += 1) { 4 | if (c0 >= 2) 5 | S2(c0); 6 | S3(c0); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/min-1-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= N; c0 += 1) 2 | for (int c1 = 0; c1 <= min(min(M, c0), N - c0); c1 += 1) 3 | S1(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/min-1-1.st: -------------------------------------------------------------------------------- 1 | domain: "[M, N] -> { S1[i0, i1] : i0 >= 1 and i1 >= 0 and i1 <= M and i1 <= i0 and i1 <= N - i0 }" 2 | child: 3 | context: "[M, N] -> { [] }" 4 | child: 5 | schedule: "[M, N] -> [{ S1[i0, i1] -> [(i0)] }, { S1[i0, i1] -> [(i1)] }]" 6 | options: "[M, N] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/min-2-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= N; c0 += 1) 2 | for (int c1 = 0; c1 <= min(min(M, c0), N - c0); c1 += 1) 3 | for (int c2 = 0; c2 <= min(min(M, c0), N - c0); c2 += 1) 4 | S1(c0, c1, c2); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/min-3-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= min(10, M); c0 += 1) 2 | for (int c1 = 0; c1 <= min(10, M); c1 += 1) 3 | S1(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/min-3-1.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[i0, i1] : i0 >= 0 and i0 <= M and i0 <= 10 and i1 >= 0 and i1 <= M and i1 <= 10 }" 2 | child: 3 | context: "[M] -> { [] : M >= 0 }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0, i1] -> [(i0)] }, { S1[i0, i1] -> [(i1)] }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/min-4-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = max(-M, -N); c0 <= min(N, O); c0 += 1) 2 | S1(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/min-4-1.st: -------------------------------------------------------------------------------- 1 | domain: "[M, N, O] -> { S1[i0] : i0 >= -M and i0 >= -N and i0 <= N and i0 <= O }" 2 | child: 3 | context: "[M, N, O] -> { [] }" 4 | child: 5 | schedule: "[M, N, O] -> [{ S1[i0] -> [(i0)] }]" 6 | options: "[M, N, O] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/mod.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 3; c0 += 1) 2 | if ((c0 + 1) % 3 >= 1) 3 | S1(c0); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/mod.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[i0] : exists (e0 = floor((1 + i0)/3): 3e0 <= i0 and 3e0 >= -1 + i0 and i0 >= 0 and i0 <= 3) }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i0] -> [(i0)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/mod2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 3; c0 += 1) 2 | if ((c0 + 1) % 3 >= 1) 3 | S1(c0); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/mod2.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[i] : exists (e0 = floor((1 + i)/3): 3e0 <= i and 3e0 >= -1 + i and i >= 0 and i <= 3) }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i] -> [(i)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/mod3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = max(0, 32 * h0 - 1991); c0 <= min(999, 32 * h0 + 31); c0 += 1) 2 | if ((32 * h0 - c0 + 32) % 64 >= 1) 3 | for (int c1 = 0; c1 <= 999; c1 += 1) 4 | S1(c0, c1); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/mod4.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 10; c0 += 3) { 2 | S1(c0, (c0 + 1) / 3, (c0 + 1) / 3, 2, (c0 - 2) / 3); 3 | S2(c0, (c0 + 1) / 3, (c0 + 1) / 3, 2, (c0 - 2) / 3); 4 | S3(c0, (c0 + 1) / 3, (c0 + 1) / 3, 2, (c0 - 2) / 3); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/mode.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= M; c0 += 1) { 2 | for (int c1 = 0; c1 <= min(N, c0); c1 += 1) { 3 | S1(c0, c1); 4 | S2(c0, c1); 5 | } 6 | for (int c1 = c0 + 1; c1 <= N; c1 += 1) 7 | S2(c0, c1); 8 | for (int c1 = max(0, N + 1); c1 <= c0; c1 += 1) 9 | S1(c0, c1); 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/multi-mm-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= M; c0 += 1) { 2 | for (int c1 = 0; c1 <= min(N, c0); c1 += 1) { 3 | S1(c0, c1); 4 | S2(c0, c1); 5 | } 6 | for (int c1 = N + 1; c1 <= c0; c1 += 1) 7 | S1(c0, c1); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/multi-stride.c: -------------------------------------------------------------------------------- 1 | { 2 | } 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/multi-stride.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[i0, i1, i2] : 2i1 = -1 + i0 and 6i2 = -2 + i0 and i0 >= 0 and i0 <= 100 }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i0, i1, i2] -> [(i0)] }, { S1[i0, i1, i2] -> [(i1)] }, { S1[i0, i1, i2] -> [(i2)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/multi-stride2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 5; c0 <= 100; c0 += 6) 2 | S1(c0, (c0 - 1) / 2, (c0 - 2) / 3); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/multi-stride2.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[i0, i1, i2] : 2i1 = -1 + i0 and 3i2 = -2 + i0 and i0 >= 0 and i0 <= 100 }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i0, i1, i2] -> [(i0)] }, { S1[i0, i1, i2] -> [(i1)] }, { S1[i0, i1, i2] -> [(i2)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/mxm-shared.c: -------------------------------------------------------------------------------- 1 | if (N >= g0 + t1 + 1 && t1 <= 7 && g4 % 4 == 0) 2 | for (int c0 = t0; c0 <= min(127, N - g1 - 1); c0 += 16) 3 | S1(g0 + t1, g1 + c0); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/no_lindep.c: -------------------------------------------------------------------------------- 1 | S1(N + 2); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/no_lindep.st: -------------------------------------------------------------------------------- 1 | domain: "[M, N] -> { S1[2 + N] }" 2 | child: 3 | context: "[M, N] -> { [] }" 4 | child: 5 | schedule: "[M, N] -> [{ S1[i0] -> [(1 + M)] }, { S1[i0] -> [(N)] }]" 6 | options: "[M, N] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/nul_basic1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= M; c0 += 2) 2 | S1(c0, c0 / 2); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/nul_basic1.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[i0, i1] : 2i1 = i0 and i0 >= 0 and i0 <= M }" 2 | child: 3 | context: "[M] -> { [] }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0, i1] -> [(i0)] }, { S1[i0, i1] -> [(i1)] }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/nul_basic2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= n; c0 += 2) { 2 | if (c0 % 4 == 0) 3 | S2(c0, c0 / 4); 4 | S1(c0, c0 / 2); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/nul_complex1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 5 * n; c0 += 1) 2 | for (int c1 = max(-((5 * n - c0 + 1) % 2) - n + c0 + 1, 2 * ((c0 + 2) / 3)); c1 <= min(c0, n + c0 - (n + c0 + 2) / 3); c1 += 2) 3 | S1((3 * c1 / 2) - c0, c0 - c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/nul_complex1.st: -------------------------------------------------------------------------------- 1 | domain: "[n] -> { S1[i0, i1] : i0 >= 0 and i0 <= n and i1 >= 0 and i1 <= n }" 2 | child: 3 | context: "[n] -> { [] }" 4 | child: 5 | schedule: "[n] -> [{ S1[i0, i1] -> [(2i0 + 3i1)] }, { S1[i0, i1] -> [(2i0 + 2i1)] }]" 6 | options: "[n] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/param-split.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= max(0, M); c0 += 1) { 2 | if (M >= c0) 3 | S1(c0); 4 | if (c0 == 0) 5 | S2(0); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/rectangle.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 2 * n; c0 += 1) 2 | for (int c1 = max(0, -n + c0); c1 <= min(n, c0); c1 += 1) 3 | S1(c1, c0 - c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/rectangle.st: -------------------------------------------------------------------------------- 1 | domain: "[n] -> { S1[i0, i1] : i0 >= 0 and i0 <= n and i1 >= 0 and i1 <= n }" 2 | child: 3 | context: "[n] -> { [] : n >= 0 }" 4 | child: 5 | schedule: "[n] -> [{ S1[i0, i1] -> [(i0 + i1)] }]" 6 | options: "[n] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-bastoul3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 3; c0 <= 9; c0 += 1) 2 | for (int c1 = max(c0 - 6, -(c0 % 2) + 2); c1 <= min(3, c0 - 2); c1 += 2) 3 | S1(c0, c1, (c0 - c1) / 2); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-bastoul3.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[i0, i1, i2] : 2i2 = i0 - i1 and i1 >= 1 and i1 <= 3 and i1 <= -2 + i0 and i1 >= -6 + i0 }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i0, i1, i2] -> [(i0)] }, { S1[i0, i1, i2] -> [(i1)] }, { S1[i0, i1, i2] -> [(i2)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-fusion1.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 0; c0 <= M; c0 += 1) 3 | S1(c0); 4 | for (int c0 = 1; c0 <= M; c0 += 1) 5 | S2(c0); 6 | for (int c0 = 0; c0 <= M; c0 += 1) 7 | S3(c0); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-jacobi2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 < M; c0 += 1) 2 | for (int c1 = 0; c1 < M; c1 += 1) 3 | S1(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-jacobi3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= M; c0 += 1) { 2 | for (int c2 = 2; c2 < N; c2 += 1) 3 | for (int c3 = 2; c3 < N; c3 += 1) 4 | S1(c0, c2, c3); 5 | for (int c2 = 2; c2 < N; c2 += 1) 6 | for (int c3 = 2; c3 < N; c3 += 1) 7 | S2(c0, c2, c3); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-lim-lam2.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 1; c0 <= M; c0 += 1) 3 | S1(c0); 4 | for (int c0 = 1; c0 <= M; c0 += 1) 5 | for (int c1 = 2; c1 <= N; c1 += 1) 6 | S2(c0, c1); 7 | for (int c0 = 1; c0 <= M; c0 += 1) 8 | for (int c1 = 1; c1 < N; c1 += 1) 9 | S3(c0, c1); 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-lim-lam6.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 0; c0 <= M; c0 += 1) 3 | for (int c1 = 1; c1 <= M; c1 += 1) 4 | S1(c0, c1); 5 | for (int c0 = 0; c0 <= M; c0 += 1) 6 | for (int c1 = 1; c1 <= M; c1 += 1) 7 | S2(c1, c0); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-loechner3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= M; c0 += 1) 2 | for (int c1 = 2; c1 <= M + c0; c1 += 1) 3 | for (int c2 = max(1, -c0 + c1); c2 <= min(M, c1 - 1); c2 += 1) 4 | S1(c0, c2, c1 - c2); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-loechner4.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 2 * M; c0 += 1) 2 | for (int c1 = 1; c1 <= M; c1 += 1) 3 | for (int c2 = 1; c2 <= M; c2 += 1) 4 | for (int c3 = max(1, -M + c0); c3 <= min(M, c0 - 1); c3 += 1) 5 | S1(c2, c1, c3, c0 - c3); 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-loechner5.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= M; c0 += 1) 2 | for (int c1 = 1; c1 <= M; c1 += 1) 3 | for (int c2 = 1; c2 <= M; c2 += 1) 4 | for (int c3 = 1; c3 <= M; c3 += 1) 5 | S1(c1, c2, c0, c3); 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-mg-psinv.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 < O; c0 += 1) 2 | for (int c1 = 3; c1 < 2 * N - 2; c1 += 2) { 3 | for (int c3 = 1; c3 <= M; c3 += 1) { 4 | S1(c0, (c1 + 1) / 2, c3); 5 | S2(c0, (c1 + 1) / 2, c3); 6 | } 7 | for (int c3 = 2; c3 < M; c3 += 1) 8 | S3(c0, (c1 + 1) / 2, c3); 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-mg-resid.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 < O; c0 += 1) 2 | for (int c1 = 3; c1 < 2 * N - 2; c1 += 2) { 3 | for (int c3 = 1; c3 <= M; c3 += 1) { 4 | S1(c0, (c1 + 1) / 2, c3); 5 | S2(c0, (c1 + 1) / 2, c3); 6 | } 7 | for (int c3 = 2; c3 < M; c3 += 1) 8 | S3(c0, (c1 + 1) / 2, c3); 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-pingali1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= M; c0 += 1) 2 | for (int c1 = 1; c1 < 2 * N; c1 += 1) { 3 | for (int c2 = max(1, -N + c1); c2 < (c1 + 1) / 2; c2 += 1) 4 | S1(c0, c1 - c2, c2); 5 | if ((c1 + 1) % 2 == 0) 6 | S2(c0, (c1 + 1) / 2); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-pingali2.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 1; c0 <= M; c0 += 1) 3 | for (int c1 = 1; c1 <= M; c1 += 1) 4 | S1(c0, c1); 5 | for (int c0 = 1; c0 <= M; c0 += 1) 6 | for (int c1 = 1; c1 <= M; c1 += 1) 7 | S2(c0, c1); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-pingali3.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 1; c0 <= M; c0 += 1) 3 | for (int c1 = 1; c1 <= M; c1 += 1) 4 | S1(c0, c1); 5 | for (int c0 = 1; c0 <= M; c0 += 1) 6 | for (int c1 = 1; c1 <= M; c1 += 1) 7 | for (int c2 = 1; c2 <= M; c2 += 1) 8 | S2(c0, c1, c2); 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-pingali4.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 1; c0 <= M; c0 += 1) 3 | for (int c1 = 1; c1 <= M; c1 += 1) 4 | S1(c0, c1); 5 | for (int c0 = 1; c0 <= M; c0 += 1) 6 | for (int c1 = 1; c1 <= M; c1 += 1) 7 | S2(c0, c1); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-pingali6.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= M; c0 += 1) { 2 | for (int c2 = 2; c2 < N; c2 += 1) 3 | for (int c3 = 2; c3 < N; c3 += 1) 4 | S1(c0, c2, c3); 5 | for (int c2 = 2; c2 < N; c2 += 1) 6 | for (int c3 = 2; c3 < N; c3 += 1) 7 | S2(c0, c2, c3); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-stride.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= M; c0 += 7) 2 | S1(c0, (c0 - 2) / 7); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-stride.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[i0, i1] : 7i1 = -2 + i0 and i0 >= 2 and i0 <= M }" 2 | child: 3 | context: "[M] -> { [] }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0, i1] -> [(i0)] }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-stride2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= M; c0 += 7) 2 | S1(c0, (c0 - 2) / 7); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-stride2.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[i0, i1] : 7i1 = -2 + i0 and i0 >= 0 and i0 <= M }" 2 | child: 3 | context: "[M] -> { [] }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0, i1] -> [(i0)] }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-tang-xue1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 9; c0 += 2) 2 | for (int c1 = 0; c1 <= min(4, c0 + 3); c1 += 2) 3 | for (int c2 = max(1, c0); c2 <= min(c0 + 1, c0 - c1 + 4); c2 += 1) 4 | for (int c3 = max(1, -c0 + c1 + c2); c3 <= min(4, -c0 + c1 + c2 + 1); c3 += 1) 5 | S1(c0 / 2, (-c0 + c1) / 2, -c0 + c2, -c1 + c3); 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-two.c: -------------------------------------------------------------------------------- 1 | S1(1, 1, 5); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/reservoir-two.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[i0, i1, i2] : 2i1 = 3 - i0 and 2i2 = 9 + i0 and i0 >= 0 and i0 <= 1 }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S1[i0, i1, i2] -> [(i0)] }, { S1[i0, i1, i2] -> [(i1)] }, { S1[i0, i1, i2] -> [(i2)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/singleton.c: -------------------------------------------------------------------------------- 1 | { 2 | S2(); 3 | S1(); 4 | } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/singleton.st: -------------------------------------------------------------------------------- 1 | domain: "{ S1[]; S2[] }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | sequence: 6 | - filter: "{ S2[] }" 7 | - filter: "{ S1[] }" 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/square+triangle-1-1-2-3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= M; c0 += 1) { 2 | S1(c0, 1); 3 | for (int c1 = 2; c1 <= c0; c1 += 1) { 4 | S1(c0, c1); 5 | S2(c0, c1); 6 | } 7 | for (int c1 = c0 + 1; c1 <= M; c1 += 1) 8 | S1(c0, c1); 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/stride.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 3; c0 <= 24; c0 += 3) 3 | S2(c0, c0 / 3); 4 | S1(25); 5 | for (int c0 = 27; c0 <= 100; c0 += 3) 6 | S2(c0, c0 / 3); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/stride.st: -------------------------------------------------------------------------------- 1 | domain: "{ S2[i0, i1] : 3i1 = i0 and i0 >= 3 and i0 <= 100; S1[25] }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S2[i0, i1] -> [(i0)]; S1[i0] -> [(i0)] }, { S2[i0, i1] -> [(i1)]; S1[i0] -> [(0)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/stride2.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 3; c0 <= 26; c0 += 3) 3 | S2(c0, c0 / 3); 4 | S1(27); 5 | S2(27, 9); 6 | for (int c0 = 30; c0 <= 100; c0 += 3) 7 | S2(c0, c0 / 3); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/stride2.st: -------------------------------------------------------------------------------- 1 | domain: "{ S2[i0, i1] : 3i1 = i0 and i0 >= 3 and i0 <= 100; S1[27] }" 2 | child: 3 | context: "{ [] }" 4 | child: 5 | schedule: "[{ S2[i0, i1] -> [(i0)]; S1[i0] -> [(i0)] }, { S2[i0, i1] -> [(i1)]; S1[i0] -> [(0)] }]" 6 | options: "{ separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/stride3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = max(1, m); c0 <= n; c0 += 1) 2 | S1(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/stride3.st: -------------------------------------------------------------------------------- 1 | domain: "[m, n] -> { S1[i] : i >= 1 and i <= n and i >= m }" 2 | child: 3 | context: "[m, n] -> { [] }" 4 | child: 5 | schedule: "[m, n] -> [{ S1[i0] -> [(50i0)] }]" 6 | options: "[m, n] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/stride4.c: -------------------------------------------------------------------------------- 1 | if (t >= 0 && t <= 15) 2 | for (int c0 = t; c0 <= 99; c0 += 16) 3 | S1(c0, t); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/stride4.st: -------------------------------------------------------------------------------- 1 | domain: "[t] -> { S1[i0, t] : exists (e0 = floor((t - i0)/16): 16e0 = t - i0 and i0 >= 0 and i0 <= 99 and t >= 0 and t <= 15) }" 2 | child: 3 | context: "[t] -> { [] }" 4 | child: 5 | schedule: "[t] -> [{ S1[i0, i1] -> [(i0)] }, { S1[i0, i1] -> [(i1)] }]" 6 | options: "[t] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/tiling.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= n / 10; c0 += 1) 2 | for (int c1 = 10 * c0; c1 <= min(n, 10 * c0 + 9); c1 += 1) 3 | S1(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/tiling.st: -------------------------------------------------------------------------------- 1 | domain: "[n] -> { S1[ii, i] : i >= 0 and i <= n and i <= 9 + 10ii and i >= 10ii }" 2 | child: 3 | context: "[n] -> { [] : n >= 0 }" 4 | child: 5 | schedule: "[n] -> [{ S1[ii, i] -> [(ii)] }, { S1[ii, i] -> [(i)] }]" 6 | options: "[n] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/uday_scalars.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 0; c0 <= n; c0 += 1) 3 | S1(c0, 0, 0); 4 | for (int c0 = 0; c0 <= n; c0 += 1) 5 | S2(0, c0, 0); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/union.c: -------------------------------------------------------------------------------- 1 | if (M >= 11) { 2 | for (int c0 = -100; c0 <= 0; c0 += 1) 3 | S1(-c0); 4 | } else { 5 | for (int c0 = 0; c0 <= 100; c0 += 1) 6 | S1(c0); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/union.st: -------------------------------------------------------------------------------- 1 | domain: "[M] -> { S1[i0] : i0 >= 0 and i0 <= 100 }" 2 | child: 3 | context: "[M] -> { [] : M >= 1 or M <= -1 }" 4 | child: 5 | schedule: "[M] -> [{ S1[i0] -> [(i0)] : M <= 10; S1[i0] -> [(-i0)] : M >= 11 }]" 6 | options: "[M] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/unroll.c: -------------------------------------------------------------------------------- 1 | { 2 | S1(0); 3 | S1(1); 4 | S1(2); 5 | S1(3); 6 | S1(4); 7 | S1(5); 8 | S1(6); 9 | S1(7); 10 | S1(8); 11 | S1(9); 12 | S1(10); 13 | } 14 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/unroll.st: -------------------------------------------------------------------------------- 1 | domain: "[n] -> { S1[i] : i >= 0 and i <= 10 }" 2 | child: 3 | context: "[n] -> { [] }" 4 | child: 5 | schedule: "[n] -> [{ S1[i] -> [(i)] }]" 6 | options: "[n] -> { unroll[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/unroll2.c: -------------------------------------------------------------------------------- 1 | if (n >= -1 && n <= 9) { 2 | if (n >= 0) 3 | S1(n); 4 | S1(n + 1); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/unroll2.st: -------------------------------------------------------------------------------- 1 | domain: "[n] -> { S1[i] : i >= n and i <= 1 + n and n <= 9 and i >= 0 }" 2 | child: 3 | context: "[n] -> { [] }" 4 | child: 5 | schedule: "[n] -> [{ S1[i] -> [(i)] }]" 6 | options: "[n] -> { unroll[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/walters2.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c1 = 0; c1 <= 51; c1 += 1) 3 | S2(0, c1); 4 | for (int c0 = 1; c0 <= 24; c0 += 1) { 5 | S2(c0, 0); 6 | for (int c1 = 1; c1 <= 50; c1 += 1) 7 | S1(c0, c1); 8 | S2(c0, 51); 9 | } 10 | for (int c1 = 0; c1 <= 51; c1 += 1) 11 | S2(25, c1); 12 | } 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/walters3.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 2; c0 <= 8; c0 += 2) { 3 | S1(c0, c0 / 2, c0 / 2); 4 | S2(c0, c0 / 2, c0 / 2); 5 | } 6 | S2(10, 5, 5); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/wavefront.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= n + m; c0 += 1) 2 | for (int c1 = max(1, -m + c0); c1 <= min(n, c0 - 1); c1 += 1) 3 | S1(c1, c0 - c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/wavefront.st: -------------------------------------------------------------------------------- 1 | domain: "[n, m] -> { S1[i0, i1] : i0 >= 1 and i0 <= n and i1 >= 1 and i1 <= m }" 2 | child: 3 | context: "[n, m] -> { [] }" 4 | child: 5 | schedule: "[n, m] -> [{ S1[i0, i1] -> [(i0 + i1)] }, { S1[i0, i1] -> [(i0)] }]" 6 | options: "[n, m] -> { separate[i0] }" 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/youcef.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 5; c0 += 1) { 2 | S1(c0, c0); 3 | for (int c1 = c0; c1 <= 5; c1 += 1) 4 | S2(c0, c1); 5 | S3(c0, 5); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/cloog/youcefn.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 1; c0 <= n; c0 += 1) { 3 | S1(c0, c0); 4 | for (int c1 = c0; c1 <= n; c1 += 1) 5 | S2(c0, c1); 6 | S3(c0, n); 7 | } 8 | for (int c0 = n + 1; c0 <= m; c0 += 1) 9 | S3(c0, n); 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component0.c: -------------------------------------------------------------------------------- 1 | { 2 | A(); 3 | for (int c0 = 0; c0 <= 9; c0 += 1) 4 | B(c0); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component0.st: -------------------------------------------------------------------------------- 1 | domain: "{ A[]; B[i] : 0 <= i < 10 }" 2 | child: 3 | schedule: "[{ A[] -> [0]; B[i] -> [i] }]" 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component1.c: -------------------------------------------------------------------------------- 1 | { 2 | A(); 3 | for (int c0 = 0; c0 <= 9; c0 += 1) 4 | B(c0); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component1.st: -------------------------------------------------------------------------------- 1 | domain: "{ A[]; B[i] : 0 <= i < 10 }" 2 | child: 3 | schedule: "[{ A[] -> [0]; B[i] -> [i] }]" 4 | child: 5 | sequence: 6 | - filter: "{ A[] }" 7 | - filter: "{ B[i] }" 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 9; c0 += 1) { 2 | B(c0); 3 | if (c0 == 0) 4 | A(); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component2.st: -------------------------------------------------------------------------------- 1 | domain: "{ A[]; B[i] : 0 <= i < 10 }" 2 | child: 3 | schedule: "[{ A[] -> [0]; B[i] -> [i] }]" 4 | child: 5 | sequence: 6 | - filter: "{ B[i] }" 7 | - filter: "{ A[] }" 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component3.c: -------------------------------------------------------------------------------- 1 | { 2 | A(); 3 | for (int c0 = 0; c0 <= 9; c0 += 1) 4 | B(c0); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component3.st: -------------------------------------------------------------------------------- 1 | domain: "{ A[]; B[i] : 0 <= i < 10 }" 2 | child: 3 | schedule: "[{ A[] -> [0]; B[i] -> [i] }]" 4 | child: 5 | set: 6 | - filter: "{ B[i] }" 7 | - filter: "{ A[] }" 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component4.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c1 = 0; c1 <= 9; c1 += 1) 3 | A(c1); 4 | for (int c0 = 0; c0 <= 9; c0 += 1) 5 | for (int c2 = 0; c2 <= 9; c2 += 1) 6 | B(c0, c2); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component4.st: -------------------------------------------------------------------------------- 1 | domain: "{ A[i] : 0 <= i < 10; B[i,j] : 0 <= i,j < 10 }" 2 | child: 3 | schedule: "[{ A[i] -> [0]; B[i,j] -> [i] }]" 4 | child: 5 | sequence: 6 | - filter: "{ A[i] }" 7 | - filter: "{ B[i,j] }" 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component5.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 9; c0 += 1) 2 | for (int c1 = 0; c1 <= 9; c1 += 1) { 3 | if (c0 == 0) 4 | A(c1); 5 | B(c0, c1); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component5.st: -------------------------------------------------------------------------------- 1 | domain: "{ A[i] : 0 <= i < 10; B[i,j] : 0 <= i,j < 10 }" 2 | child: 3 | schedule: "[{ A[i] -> [0]; B[i,j] -> [i] }]" 4 | child: 5 | schedule: "[{ A[i] -> [i]; B[i,j] -> [j] }]" 6 | child: 7 | sequence: 8 | - filter: "{ A[i] }" 9 | - filter: "{ B[i,j] }" 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component6.c: -------------------------------------------------------------------------------- 1 | { 2 | A(); 3 | for (int c0 = 0; c0 <= 9; c0 += 1) 4 | B(c0); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/component7.c: -------------------------------------------------------------------------------- 1 | { 2 | S(); 3 | for (int c0 = 0; c0 < K; c0 += 32) 4 | for (int c1 = c0; c1 <= min(K - 1, c0 + 31); c1 += 1) 5 | T(c1); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/disjuncts.in: -------------------------------------------------------------------------------- 1 | # Check that conditions are hoisted up from the innermost loop 2 | [n] -> { a[i,j,k,l] -> [i,j,0,k,l] : 3 | 0 <= i,j,k,l <= n and (i = 0 or j = 0 or i = n or j = n); 4 | b[i,j,k,l] -> [i,j,1,k,l] : 5 | 0 <= i,j,k,l <= n and (i = 0 or j = 0 or i = n or j = n) } 6 | { : } 7 | { [i,j,t,k,l] -> atomic[x] } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/disjuncts2.c: -------------------------------------------------------------------------------- 1 | if (P >= Q + 1 || Q >= P + 1) 2 | for (int c0 = 0; c0 < N; c0 += 1) 3 | S(c0); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/disjuncts2.st: -------------------------------------------------------------------------------- 1 | # Check that the loop is generated only once with an outer disjunctive condition 2 | domain: "[N, Q, P] -> { S[i0] : 0 <= i0 < N and (P > Q or P < Q) }" 3 | child: 4 | schedule: "[N, Q, P] -> [{ S[i0] -> [(i0)] }]" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/dwt.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 < Ncl; c0 += 1) { 2 | if (Ncl >= c0 + 2 && c0 >= 1) { 3 | S(c0, 28); 4 | } else if (c0 == 0) { 5 | S(0, 26); 6 | } else { 7 | S(Ncl - 1, 27); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/dwt.in: -------------------------------------------------------------------------------- 1 | [Ncl] -> { S[j, 28] -> [j] : j <= -2 + Ncl and Ncl <= 256 and Ncl >= 40 and j >= 1; S[0, 26] -> [0] : Ncl <= 256 and Ncl >= 40; S[-1 + Ncl, 27] -> [-1 + Ncl] : Ncl <= 256 and Ncl >= 40 } 2 | [Ncl] -> { : Ncl >= 40 and Ncl <= 256 } 3 | { } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/empty.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 10; c0 += 1) { 2 | S0(c0); 3 | S1(c0); 4 | if (c0 == 5) 5 | S2(); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/empty.in: -------------------------------------------------------------------------------- 1 | # Earlier versions of isl would end up with an empty partial 2 | # executed relation and fail to detect this emptiness. 3 | [M] -> { S0[i] -> [i, -M] : 0 <= i <= 10; S1[i] -> [i, 0] : 0 <= i <= 10; S2[] -> [5, 0] } 4 | [M] -> { : M >= 1 } 5 | { } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/filter.c: -------------------------------------------------------------------------------- 1 | if (n >= m + 1) { 2 | for (int c0 = 0; c0 < n; c0 += 1) 3 | for (int c2 = 0; c2 < n; c2 += 1) 4 | A(c0, c2); 5 | } else { 6 | for (int c0 = 0; c0 < n; c0 += 1) 7 | for (int c2 = 0; c2 < n; c2 += 1) 8 | A(c0, c2); 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/gemm.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 < ni; c0 += 1) 2 | for (int c1 = 0; c1 < nj; c1 += 1) { 3 | S_2(c0, c1); 4 | for (int c2 = 0; c2 < nk; c2 += 1) 5 | S_4(c0, c1, c2); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/hoist2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 5; c0 += 1) 2 | if (c0 <= 3 || (b == 1 && t1 + c0 >= 10) || (t1 == 5 && b == 1 && c0 == 4)) 3 | for (int c1 = t1 - 64 * b + 64; c1 <= min(70, -c0 + 73); c1 += 64) 4 | if (c0 <= 3 || (t1 + c0 >= 10 && c1 == t1) || c1 == 5) 5 | A(c0, 64 * b + c1 - 8); 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/isolate1.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 0; c0 <= 3; c0 += 1) 3 | A(c0); 4 | for (int c0 = 4; c0 <= 6; c0 += 1) 5 | A(c0); 6 | for (int c0 = 7; c0 <= 99; c0 += 1) 7 | A(c0); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/isolate1.st: -------------------------------------------------------------------------------- 1 | # Check that the isolate option is adjusted by schedule space scaling 2 | domain: "{ A[i] : 0 <= i < 100 }" 3 | child: 4 | schedule: "[{ A[i] -> [3i] }]" 5 | options: "{ isolate[[] -> [x]] : 10 <= x <= 20 }" 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/isolate2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 99; c0 += 1) { 2 | if (c0 >= 4 && c0 <= 6) { 3 | for (int c1 = 0; c1 <= 99; c1 += 1) 4 | A(c0, c1); 5 | } else { 6 | for (int c1 = 0; c1 <= 99; c1 += 1) 7 | A(c0, c1); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/isolate2.st: -------------------------------------------------------------------------------- 1 | # Check that the isolate option is adjusted by schedule space scaling 2 | domain: "{ A[i,j] : 0 <= i,j < 100 }" 3 | child: 4 | schedule: "[{ A[i,j] -> [3i] }]" 5 | child: 6 | schedule: "[{ A[i,j] -> [3j] }]" 7 | options: "{ isolate[[x] -> [y]] : 10 <= x <= 20 }" 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/isolate3.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 0; c0 <= 9; c0 += 1) 3 | A(c0); 4 | A(10); 5 | A(11); 6 | A(12); 7 | A(13); 8 | A(14); 9 | A(15); 10 | A(16); 11 | A(17); 12 | A(18); 13 | A(19); 14 | A(20); 15 | for (int c0 = 21; c0 <= 99; c0 += 1) 16 | A(c0); 17 | } 18 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/isolate3.st: -------------------------------------------------------------------------------- 1 | # Check use of options specific to isolated part 2 | domain: "{ A[i] : 0 <= i < 100 }" 3 | child: 4 | schedule: "[{ A[i] -> [i] }]" 5 | options: "{ isolate[[] -> [x]] : 10 <= x <= 20; [isolate[] -> unroll[x]] }" 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/isolate4.c: -------------------------------------------------------------------------------- 1 | { 2 | A(0); 3 | A(1); 4 | A(2); 5 | A(3); 6 | A(4); 7 | for (int c0 = 5; c0 <= 15; c0 += 1) 8 | A(c0); 9 | A(16); 10 | A(17); 11 | A(18); 12 | A(19); 13 | } 14 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/isolate4.st: -------------------------------------------------------------------------------- 1 | # Check that generic options are not applied to isolated part 2 | domain: "{ A[i] : 0 <= i < 20 }" 3 | child: 4 | schedule: "[{ A[i] -> [i] }]" 5 | options: "{ isolate[[] -> [x]] : 5 <= x <= 15; unroll[x] }" 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/isolate5.st: -------------------------------------------------------------------------------- 1 | # Check that use of isolate option prevents shifted stride detection 2 | domain: "{ A[i,j] : 0 <= i < 100 and 0 <= j < 2; B[i,j] : 0 <= i < 100 and 0 <= j < 2 }" 3 | child: 4 | schedule: "[{ A[i,j] -> [2i]; B[i,j] -> [2i+1] }, { A[i,j] -> [j]; B[i,j] -> [j]}]" 5 | options: "{ isolate[[] -> [x, y]] : 10 <= x < 90 }" 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/jacobi_kernel4.c: -------------------------------------------------------------------------------- 1 | if (8 * a + 64 * b >= t0 + 2 * t + 512 * floord(-t0 - 8 * a + 64 * b + 2 * t - 1, 512) + 512 && t0 + 512 * floord(-t0 - 8 * a + 64 * b + 2 * t - 1, 512) >= -511 && t0 + 512 * floord(-t0 - 8 * a + 64 * b + 2 * t - 1, 512) <= 1310206) 2 | S_0(t, -((-t0 - 8 * a + 64 * b + 2 * t + 511) % 512) - 8 * a + 64 * b + 2 * t + 511); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/mod.c: -------------------------------------------------------------------------------- 1 | if (2 * (n % 100) == 3 * (m % 200)) 2 | A(); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/mod.in: -------------------------------------------------------------------------------- 1 | # check that modulo constraint is generated correctly 2 | [n, m] -> { A[] -> [] : 2 * (n % 100) = 3 * (m % 200) } 3 | [n, m] -> { : m, n >= 0 } 4 | {} 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/README: -------------------------------------------------------------------------------- 1 | The tests in this directory have been adapted from the corresponding omega+ 2 | test cases. 3 | The options have been derived semi-automatically and may not always 4 | correspond to the intended meaning of the specified "effort" in the omega+ 5 | test cases. 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/basics-0.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 5; c0 <= 8; c0 += 1) 3 | s0(c0); 4 | for (int c0 = 10; c0 <= 16; c0 += 2) 5 | s0(c0); 6 | for (int c0 = 20; c0 <= 25; c0 += 1) 7 | s0(c0); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/basics-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1] -> [In_1] : (In_1 >= 5 and In_1 <= 8) or (exists (e0 = [(In_1)/2]: 2e0 = In_1 and In_1 >= 10 and In_1 <= 16)) or (In_1 >= 20 and In_1 <= 25) } 2 | { : } 3 | { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/basics-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = -9; c0 <= 9; c0 += 1) 2 | for (int c1 = max(1, -c0 + 1); c1 <= min(10, -c0 + 10); c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/basics-1.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : In_2 >= 1 - In_1 and In_2 >= 1 and In_2 <= 10 - In_1 and In_2 <= 10 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/chosol-0.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c1 = 2; c1 <= n; c1 += 1) 3 | s0(c1); 4 | for (int c1 = 1; c1 < n; c1 += 1) { 5 | for (int c3 = c1 + 1; c3 <= n; c3 += 1) 6 | s1(c3, c1); 7 | s2(c1 + 1); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/chosol-0.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i] -> [0, i, 0, 0] : i >= 2 and i <= n; s1[i, j] -> [1, j, 0, i] : j >= 1 and j <= -1 + i and i <= n; s2[i] -> [1, -1 + i, 1, 0] : i >= 2 and i <= n } 2 | { : } 3 | [n] -> { [i0, i1, i2, i3] -> atomic[o0] : o0 <= 2; [i0, i1, i2, i3] -> separate[o0] : o0 >= 3 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/chosol-1.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c1 = 2; c1 <= n; c1 += 1) 3 | s0(c1); 4 | for (int c1 = 1; c1 < n; c1 += 1) { 5 | for (int c3 = c1 + 1; c3 <= n; c3 += 1) 6 | s1(c3, c1); 7 | s2(c1 + 1); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/chosol-1.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i] -> [0, i, 0, 0] : i >= 2 and i <= n; s1[i, j] -> [1, j, 0, i] : j >= 1 and j <= -1 + i and i <= n; s2[i] -> [1, -1 + i, 1, 0] : i >= 2 and i <= n } 2 | { : } 3 | [n] -> { [i0, i1, i2, i3] -> atomic[o0] : o0 <= 1; [i0, i1, i2, i3] -> separate[o0] : o0 >= 2 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/code_gen-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 8; c0 += 1) 2 | for (int c1 = 0; c1 <= 7; c1 += 1) { 3 | if (c0 >= 2 && c0 <= 6 && c1 <= 4) 4 | s1(c0, c1); 5 | if (c1 + 1 >= c0) 6 | s0(c0, c1); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/code_gen-0.in: -------------------------------------------------------------------------------- 1 | { s1[In_1, In_2] -> [In_1, In_2] : In_1 >= 2 and In_1 <= 6 and In_2 >= 0 and In_2 <= 4; s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 1 and In_2 >= -1 + In_1 and In_2 <= 7 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 1; [i0, i1] -> separate[o0] : o0 >= 2 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/code_gen-1.in: -------------------------------------------------------------------------------- 1 | { s1[In_1, In_2] -> [In_1, In_2] : In_1 >= 2 and In_1 <= 6 and In_2 >= 0 and In_2 <= 4; s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 1 and In_2 >= -1 + In_1 and In_2 <= 7 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/code_gen-2.in: -------------------------------------------------------------------------------- 1 | { s1[In_1, In_2] -> [In_1, In_2] : In_1 >= 2 and In_1 <= 6 and In_2 >= 0 and In_2 <= 4; s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 1 and In_2 >= -1 + In_1 and In_2 <= 7 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= -1; [i0, i1] -> separate[o0] : o0 >= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/dagstuhl1-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 99; c0 += 1) 2 | s0(c0 % 10, c0 / 10); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/dagstuhl1-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [i + 10j] : i >= 0 and i <= 9 and j >= 0 and j <= 9 } 2 | { : } 3 | { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/dagstuhl1-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 99; c0 += 1) 2 | s0(c0, c0 % 10, c0 / 10); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/dagstuhl1-1.in: -------------------------------------------------------------------------------- 1 | {s0[p,i,j] -> [p,i,j] : 0 <= i,j <= 9 && p = i+10j} 2 | { : } 3 | { [p,i,j] -> separate[o0] : o0 >= 2; [p,i,j] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/fc1-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 < n - 1; c0 += 1) { 2 | for (int c3 = 0; c3 < n - c0 - 1; c3 += 1) 3 | s0(c0 + 1, n - c3); 4 | for (int c3 = 0; c3 < n - c0 - 1; c3 += 1) 5 | for (int c6 = c0 + 2; c6 <= n; c6 += 1) 6 | s1(c0 + 1, n - c3, c6); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/fc1-0.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i, j] -> [-1 + i, 0, n - i, n - j] : i >= 1 and j >= 1 + i and j <= n; s1[i, j, k] -> [-1 + i, 1, n - i, n - j] : j >= 1 + i and k >= 1 + i and i >= 1 and j <= n and k <= n } 2 | { : } 3 | [n] -> { [i0, i1, i2, i3] -> atomic[o0] : o0 <= 2; [i0, i1, i2, i3] -> separate[o0] : o0 >= 3 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/fc2-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 < n - 1; c0 += 1) { 2 | for (int c3 = 0; c3 < n - c0 - 1; c3 += 1) 3 | s0(c0 + 1, n - c3); 4 | for (int c3 = 0; c3 < n - c0 - 1; c3 += 1) 5 | for (int c6 = c0 + 2; c6 <= n; c6 += 1) 6 | s1(c0 + 1, n - c3, c6); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/fc2-0.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i, j] -> [-1 + i, 0, n - i, n - j] : i >= 1 and j >= 1 + i and j <= n; s1[i, j, k] -> [-1 + i, 1, n - i, n - j] : j >= 1 + i and k >= 1 + i and i >= 1 and j <= n and k <= n } 2 | { : } 3 | [n] -> { [i0, i1, i2, i3] -> atomic[o0] : o0 <= 2; [i0, i1, i2, i3] -> separate[o0] : o0 >= 3 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 4 * floord(m - 1, 12) + 4; c0 <= floord(n, 3); c0 += 4) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-0.in: -------------------------------------------------------------------------------- 1 | [m, n] -> { s0[In_1] -> [In_1] : exists (e0 = [(In_1)/4]: 4e0 = In_1 and 3In_1 >= m and 3In_1 <= n) } 2 | { : } 3 | [m, n] -> { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = floord(m, 4); c0 <= n; c0 += 1) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-1.in: -------------------------------------------------------------------------------- 1 | [m, n] -> { s0[In_1] -> [In_1] : 4In_1 >= -3 + m and In_1 <= n } 2 | { : } 3 | [m, n] -> { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 4 * floord(m, 4); c0 <= n; c0 += 1) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-2.in: -------------------------------------------------------------------------------- 1 | [m, n] -> { s0[In_1] -> [In_1] : exists (e0 = [(m)/4]: 4e0 <= m and 4e0 >= -3 + m and 4e0 <= In_1 and In_1 <= n) } 2 | { : } 3 | [m, n] -> { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 3 * floord(m, 3) + 4 * floord(m, 4); c0 <= n; c0 += 1) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-3.in: -------------------------------------------------------------------------------- 1 | [m, n] -> { s0[In_1] -> [In_1] : exists (e0 = [(m)/3], e1 = [(m)/4]: 4e1 <= m and 3e0 <= m and 4e1 >= -3 + m and 3e0 >= -2 + m and In_1 <= n and 4e1 <= In_1 - 3e0) } 2 | { : } 3 | [m, n] -> { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-4.c: -------------------------------------------------------------------------------- 1 | if (n >= 3 * floord(n + 1, 3)) 2 | for (int c0 = m; c0 <= 5 * floord(n + 1, 3); c0 += 1) 3 | s0(c0); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-4.in: -------------------------------------------------------------------------------- 1 | [n, m] -> { s0[In_1] -> [In_1] : exists (e0 = [(1 + n)/3]: In_1 >= m and 5e0 >= In_1 and 3e0 <= n and 3e0 >= -1 + n) } 2 | { : } 3 | [n, m] -> { [i0] -> atomic[o0] : o0 <= -1; [i0] -> separate[o0] : o0 >= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-5.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 4 * floord(m, 32); c0 <= n; c0 += 1) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-5.in: -------------------------------------------------------------------------------- 1 | [m, n] -> { s0[In_1] -> [In_1] : exists (e0 = [(m)/32]: 32e0 <= m and 32e0 >= -31 + m and 4e0 <= In_1 and In_1 <= n) } 2 | { : } 3 | [m, n] -> { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-6.c: -------------------------------------------------------------------------------- 1 | if (m >= 8 * floord(m + 1, 8)) 2 | for (int c0 = 4 * floord(m + 1, 32); c0 <= n; c0 += 1) 3 | s0(c0); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/floor_bound-6.in: -------------------------------------------------------------------------------- 1 | [m, n] -> { s0[In_1] -> [In_1] : exists (e0 = [(1 + m)/8], e1 = [(e0)/4]: 8e0 <= m and 8e0 >= -6 + m and 4e1 <= In_1 and In_1 <= n and 32e1 <= 1 + m and 32e1 >= -30 + m) } 2 | { : } 3 | [m, n] -> { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gc-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 8; c0 += 2) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gc-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1] -> [In_1] : exists (e0 = [(In_1)/2]: 2e0 = In_1 and In_1 >= 2 and In_1 <= 8) } 2 | { : } 3 | { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/ge-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= n; c0 += 1) 2 | for (int c1 = 1; c1 <= n; c1 += 1) { 3 | for (int c3 = 1; c3 < min(c0, c1); c3 += 1) 4 | s1(c3, c0, c1); 5 | if (c0 >= c1 + 1) 6 | s0(c1, c0); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/ge-0.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[k, i] -> [i, k, 1, 0] : k >= 1 and i >= 1 + k and i <= n; s1[k, i, j] -> [i, j, 0, k] : i >= 1 + k and j >= 1 + k and k >= 1 and i <= n and j <= n } 2 | { : } 3 | [n] -> { [i0, i1, i2, i3] -> atomic[o0] : o0 <= 2; [i0, i1, i2, i3] -> separate[o0] : o0 >= 3 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/ge-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= n; c0 += 1) 2 | for (int c1 = 1; c1 <= n; c1 += 1) { 3 | for (int c3 = 1; c3 < min(c0, c1); c3 += 1) 4 | s1(c3, c0, c1); 5 | if (c0 >= c1 + 1) 6 | s0(c1, c0); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/ge-1.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[k, i] -> [i, k, 1, 0] : k >= 1 and i >= 1 + k and i <= n; s1[k, i, j] -> [i, j, 0, k] : i >= 1 + k and j >= 1 + k and k >= 1 and i <= n and j <= n } 2 | { : } 3 | [n] -> { [i0, i1, i2, i3] -> atomic[o0] : o0 <= 1; [i0, i1, i2, i3] -> separate[o0] : o0 >= 2 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 4) 2 | for (int c1 = c0; c1 <= n; c1 += 3) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-0.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(-1 + In_1)/4], e1 = [(-3 - In_1 + 4In_2)/12]: 4e0 = -1 + In_1 and 12e1 = -3 - In_1 + 4In_2 and In_1 >= 1 and In_2 >= In_1 and In_2 <= n) } 2 | { : } 3 | [n] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 4) 2 | for (int c1 = c0; c1 <= n; c1 += 8) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-1.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(-1 + In_1)/4], e1 = [(-In_1 + In_2)/8]: 4e0 = -1 + In_1 and 8e1 = -In_1 + In_2 and In_1 >= 1 and In_2 >= In_1 and In_2 <= n) } 2 | { : } 3 | [n] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 256) 2 | for (int c1 = c0; c1 <= n; c1 += 8) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-2.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(-1 + In_1)/256], e1 = [(-1 + In_2)/8]: 256e0 = -1 + In_1 and 8e1 = -1 + In_2 and In_1 >= 1 and In_2 >= In_1 and In_2 <= n) } 2 | { : } 3 | [n] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 < n; c0 += 4) 2 | for (int c1 = c0 + 1; c1 <= n; c1 += 6) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-3.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(-1 + In_1)/4], e1 = [(-1 - In_1 + In_2)/6]: 4e0 = -1 + In_1 and 6e1 = -1 - In_1 + In_2 and In_1 >= 1 and In_2 >= 1 + In_1 and In_2 <= n) } 2 | { : } 3 | [n] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-4.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 6) 2 | for (int c1 = c0; c1 <= n; c1 += 4) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-4.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(-1 + In_1)/6], e1 = [(-2 - In_1 + 3In_2)/12]: 6e0 = -1 + In_1 and 12e1 = -2 - In_1 + 3In_2 and In_1 >= 1 and In_2 >= In_1 and In_2 <= n) } 2 | { : } 3 | [n] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-5.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 12) 2 | for (int c1 = c0; c1 <= n; c1 += 8) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/gist-5.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(-1 + In_1)/12], e1 = [(-2 - In_1 + 3In_2)/24]: 12e0 = -1 + In_1 and 24e1 = -2 - In_1 + 3In_2 and In_1 >= 1 and In_2 >= In_1 and In_2 <= n) } 2 | { : } 3 | [n] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/guard1-0.c: -------------------------------------------------------------------------------- 1 | if ((n - m - 1) % 3 == 0) 2 | s0(n, m); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/guard1-0.in: -------------------------------------------------------------------------------- 1 | [n, m] -> { s0[n, m] -> [n, m] : exists (e0 = [(-2 - n + m)/3]: 3e0 = -2 - n + m) } 2 | { : } 3 | [n, m] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/guard1-1.c: -------------------------------------------------------------------------------- 1 | if ((n + m + 1) % 2 == 0) 2 | s0(n, m); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/guard1-1.in: -------------------------------------------------------------------------------- 1 | [n, m] -> { s0[n, m] -> [n, m] : exists (e0 = [(-1 - n + m)/2]: 2e0 = -1 - n + m) } 2 | { : } 3 | [n, m] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/hpf-0.c: -------------------------------------------------------------------------------- 1 | if (P2 >= 0 && P2 <= 3 && P1 == P2) 2 | for (int c0 = 0; c0 <= min(2, -P2 + 4); c0 += 1) 3 | for (int c2 = (-P2 - c0 + 6) % 3; c2 <= 3; c2 += 3) 4 | s0(c0, c0, c2, c2); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/if_then-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 100; c0 += 1) { 2 | if (n >= 2) 3 | s0(c0); 4 | for (int c1 = 1; c1 <= 100; c1 += 1) { 5 | s2(c0, c1); 6 | if (n >= 2) 7 | s1(c0, c1); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/if_then-2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 100; c0 += 1) { 2 | if (n >= 2) { 3 | s0(c0); 4 | for (int c1 = 1; c1 <= 100; c1 += 1) { 5 | s2(c0, c1); 6 | s1(c0, c1); 7 | } 8 | } else { 9 | for (int c1 = 1; c1 <= 100; c1 += 1) 10 | s2(c0, c1); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/if_then-4.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 4; c0 <= 100; c0 += 4) { 2 | for (int c1 = 1; c1 <= 100; c1 += 1) 3 | s0(c0, c1); 4 | if (c0 >= 8 && c0 <= 96) 5 | for (int c1 = 10; c1 <= 100; c1 += 1) 6 | s1(c0 + 2, c1); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/if_then-5.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 4; c0 <= 100; c0 += 4) { 2 | for (int c1 = 1; c1 <= 100; c1 += 1) 3 | s0(c0, c1); 4 | if (c0 >= 8 && c0 <= 96) 5 | for (int c1 = 10; c1 <= 100; c1 += 1) 6 | s1(c0 + 2, c1); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter1-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 9; c0 += 1) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter1-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1] -> [In_1] : In_1 >= 2 and In_1 <= 9 } 2 | { : } 3 | { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter2-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 10; c0 += 1) 2 | for (int c1 = 10; c1 <= 100; c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter2-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 1 and In_1 <= 10 and In_2 >= 10 and In_2 <= 100 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter3-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 8; c0 += 1) 2 | for (int c1 = c0 + 1; c1 <= 9; c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter3-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 2 and In_2 >= 1 + In_1 and In_2 <= 9 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter4-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 9; c0 += 1) 2 | for (int c1 = c0 + 1; c1 <= 2 * c0; c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter4-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 2 and In_2 >= 1 + In_1 and In_2 <= 2In_1 and In_1 <= 9 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter5-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 9; c0 += 1) 2 | for (int c1 = c0 + 1; c1 <= min(16, 2 * c0); c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter5-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 2 and In_2 >= 1 + In_1 and In_2 <= 2In_1 and In_2 <= 16 and In_1 <= 9 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter6-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 5; c0 += 1) 2 | for (int c1 = 12; c1 <= 17; c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter6-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 1 and In_1 <= 5 and In_2 >= 12 and In_2 <= 17 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter6-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 46; c0 <= 70; c0 += 12) 2 | s0(c0, (17 * c0 - 170) / 12); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter6-1.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, o1] : 12In_2 = -170 + 17In_1 and 12o1 = -170 + 17In_1 and In_1 >= 46 and In_1 <= 70 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter7-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 3; c0 += 2) 2 | s0(c0, (-3 * c0 + 15) / 2); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter7-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, o1] : 2In_2 = 15 - 3In_1 and 2o1 = 15 - 3In_1 and In_1 <= 3 and In_1 >= 1 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter8-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = max(exprVar2 + 1, exprVar2 + 8 * floord(-exprVar2 + exprVar1 - 1, 8) + 9); c0 <= 16; c0 += 8) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/iter9-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 15; c0 += 1) { 2 | if (((-exprVar1 + 15) % 8) + c0 <= 15) { 3 | s1(c0); 4 | s3(c0); 5 | s2(c0); 6 | s0(c0); 7 | s4(c0); 8 | } 9 | if (((-exprVar1 + 15) % 8) + c0 <= 15 || (exprVar1 - c0 + 1) % 8 == 0) 10 | s5(c0); 11 | } 12 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/lu_ijk-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 1) 2 | for (int c1 = 2; c1 <= n; c1 += 1) { 3 | for (int c3 = 1; c3 < min(c0, c1); c3 += 1) 4 | s1(c3, c1, c0); 5 | if (c1 >= c0 + 1) 6 | s0(c0, c1); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/lu_ijk-0.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[k, j] -> [k, j, 1, 0] : k >= 1 and j >= 1 + k and j <= n; s1[k, j, i] -> [i, j, 0, k] : j >= 1 + k and i >= 1 + k and k >= 1 and j <= n and i <= n } 2 | { : } 3 | [n] -> { [i0, i1, i2, i3] -> atomic[o0] : o0 <= 2; [i0, i1, i2, i3] -> separate[o0] : o0 >= 3 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/lu_ijk-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 1) 2 | for (int c1 = 2; c1 <= n; c1 += 1) { 3 | for (int c3 = 1; c3 < min(c0, c1); c3 += 1) 4 | s1(c3, c1, c0); 5 | if (c1 >= c0 + 1) 6 | s0(c0, c1); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/lu_ijk-1.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[k, j] -> [k, j, 1, 0] : k >= 1 and j >= 1 + k and j <= n; s1[k, j, i] -> [i, j, 0, k] : j >= 1 + k and i >= 1 + k and k >= 1 and j <= n and i <= n } 2 | { : } 3 | [n] -> { [i0, i1, i2, i3] -> atomic[o0] : o0 <= 1; [i0, i1, i2, i3] -> separate[o0] : o0 >= 2 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/lu_ijk-2.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[k, j] -> [k, j, 1, 0] : k >= 1 and j >= 1 + k and j <= n; s1[k, j, i] -> [i, j, 0, k] : j >= 1 + k and i >= 1 + k and k >= 1 and j <= n and i <= n } 2 | { : } 3 | [n] -> { [i0, i1, i2, i3] -> atomic[o0] : o0 <= 0; [i0, i1, i2, i3] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m1-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 9; c0 += 1) 2 | for (int c1 = 1; c1 <= 9; c1 += 1) { 3 | s0(c0, c1); 4 | if (c0 == 5) 5 | s1(5, c1); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m1-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [i, j, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[5, j] -> [5, j, 1] : j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m1-1.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [i, j, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[5, j] -> [5, j, 1] : j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 1; [i0, i1, i2] -> atomic[o0] : o0 <= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m10-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 18; c0 += 1) 2 | for (int c1 = 1; c1 <= 9; c1 += 1) { 3 | if (c0 % 2 == 0) 4 | s0(c1, c0 / 2); 5 | if (c0 <= 9) 6 | s1(c1, c0); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m10-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [4j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [2j, i, 1] : i >= 1 and i <= 9 and j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m10-1.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [4j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [2j, i, 1] : i >= 1 and i <= 9 and j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 1; [i0, i1, i2] -> atomic[o0] : o0 <= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m12-0.c: -------------------------------------------------------------------------------- 1 | for (int c1 = 1; c1 <= n; c1 += 1) 2 | for (int c2 = 1; c2 <= m; c2 += 1) 3 | s0(1, c1, c2, 0); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m12-0.in: -------------------------------------------------------------------------------- 1 | [m, n] -> { s0[1, In_2, In_3, 0] -> [1, In_2, In_3, 0] : In_3 >= 1 and In_3 <= m and In_2 >= 1 and In_2 <= n } 2 | { : } 3 | [m, n] -> { [i0, i1, i2, i3] -> separate[o0] : o0 >= 3; [i0, i1, i2, i3] -> atomic[o0] : o0 <= 2 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m2-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 9; c0 += 1) { 2 | if (c0 >= 5) { 3 | s1(c0, 1); 4 | for (int c1 = 2; c1 <= 9; c1 += 1) { 5 | s1(c0, c1); 6 | s0(c0, c1); 7 | } 8 | } else { 9 | for (int c1 = 2; c1 <= 9; c1 += 1) 10 | s0(c0, c1); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m2-0.in: -------------------------------------------------------------------------------- 1 | { s1[In_1, In_2] -> [In_1, In_2] : In_1 >= 5 and In_1 <= 9 and In_2 >= 1 and In_2 <= 9; s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 2 and In_1 <= 9 and In_2 >= 2 and In_2 <= 9 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m2-1.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 2; c0 <= 4; c0 += 1) 3 | for (int c1 = 2; c1 <= 9; c1 += 1) 4 | s0(c0, c1); 5 | for (int c0 = 5; c0 <= 9; c0 += 1) { 6 | s1(c0, 1); 7 | for (int c1 = 2; c1 <= 9; c1 += 1) { 8 | s1(c0, c1); 9 | s0(c0, c1); 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m2-1.in: -------------------------------------------------------------------------------- 1 | { s1[In_1, In_2] -> [In_1, In_2] : In_1 >= 5 and In_1 <= 9 and In_2 >= 1 and In_2 <= 9; s0[In_1, In_2] -> [In_1, In_2] : In_1 >= 2 and In_1 <= 9 and In_2 >= 2 and In_2 <= 9 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= -1; [i0, i1] -> separate[o0] : o0 >= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m3-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = -9; c0 <= 9; c0 += 1) 2 | for (int c1 = max(1, -c0 + 1); c1 <= min(10, -c0 + 10); c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m3-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : In_2 >= 1 - In_1 and In_2 >= 1 and In_2 <= 10 - In_1 and In_2 <= 10 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m4-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 9; c0 += 1) 2 | for (int c1 = 1; c1 <= 9; c1 += 1) { 3 | s0(c1, c0); 4 | s1(c1, c0); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m4-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [j, i, 1] : i >= 1 and i <= 9 and j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m4-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 9; c0 += 1) 2 | for (int c1 = 1; c1 <= 9; c1 += 1) { 3 | s0(c1, c0); 4 | s1(c1, c0); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m4-1.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [j, i, 1] : i >= 1 and i <= 9 and j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 1; [i0, i1, i2] -> atomic[o0] : o0 <= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m7-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 9; c0 += 1) 2 | for (int c1 = 1; c1 <= 9; c1 += 1) { 3 | s0(c1, c0); 4 | if (c0 % 2 == 0) 5 | s1(c1, c0); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m7-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [j, i, 1] : exists (e0 = [(j)/2]: 2e0 = j and i >= 1 and i <= 9 and j >= 2 and j <= 8) } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m7-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 9; c0 += 1) { 2 | if ((c0 + 1) % 2 == 0) { 3 | for (int c1 = 1; c1 <= 9; c1 += 1) 4 | s0(c1, c0); 5 | } else { 6 | for (int c1 = 1; c1 <= 9; c1 += 1) { 7 | s0(c1, c0); 8 | s1(c1, c0); 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m7-1.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [j, i, 1] : exists (e0 = [(j)/2]: 2e0 = j and i >= 1 and i <= 9 and j >= 2 and j <= 8) } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 1; [i0, i1, i2] -> atomic[o0] : o0 <= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m8-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 8; c0 += 2) 2 | for (int c1 = 1; c1 <= 9; c1 += 1) { 3 | if (c0 % 4 == 0) 4 | s0(c1, c0); 5 | s1(c1, c0); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m8-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [j, i, 0] : exists (e0 = [(j)/4]: 4e0 = j and i >= 1 and i <= 9 and j >= 4 and j <= 8); s1[i, j] -> [j, i, 1] : exists (e0 = [(j)/2]: 2e0 = j and i >= 1 and i <= 9 and j >= 2 and j <= 8) } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m8-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 8; c0 += 2) { 2 | if ((c0 + 2) % 4 == 0) { 3 | for (int c1 = 1; c1 <= 9; c1 += 1) 4 | s1(c1, c0); 5 | } else { 6 | for (int c1 = 1; c1 <= 9; c1 += 1) { 7 | s0(c1, c0); 8 | s1(c1, c0); 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m8-1.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [j, i, 0] : exists (e0 = [(j)/4]: 4e0 = j and i >= 1 and i <= 9 and j >= 4 and j <= 8); s1[i, j] -> [j, i, 1] : exists (e0 = [(j)/2]: 2e0 = j and i >= 1 and i <= 9 and j >= 2 and j <= 8) } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 1; [i0, i1, i2] -> atomic[o0] : o0 <= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m9-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 9; c0 += 1) 2 | for (int c1 = 1; c1 <= 9; c1 += 1) { 3 | s0(c1, c0); 4 | s1(c1, c0); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m9-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [2j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [2j, i, 1] : i >= 1 and i <= 9 and j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m9-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 9; c0 += 1) 2 | for (int c1 = 1; c1 <= 9; c1 += 1) { 3 | s0(c1, c0); 4 | s1(c1, c0); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/m9-1.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [2j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [2j, i, 1] : i >= 1 and i <= 9 and j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 1; [i0, i1, i2] -> atomic[o0] : o0 <= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/olda-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= morb; c0 += 1) 2 | for (int c1 = 1; c1 <= np; c1 += 1) 3 | for (int c2 = 1; c2 <= np; c2 += 1) { 4 | if (c2 >= c1) 5 | s0(c2, c1, c0); 6 | if (c1 >= c2) 7 | s1(c1, c2, c0); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/olda-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= morb; c0 += 1) 2 | for (int c1 = 1; c1 <= np; c1 += 1) { 3 | for (int c2 = 1; c2 < c1; c2 += 1) 4 | s1(c1, c2, c0); 5 | s0(c1, c1, c0); 6 | s1(c1, c1, c0); 7 | for (int c2 = c1 + 1; c2 <= np; c2 += 1) 8 | s0(c2, c1, c0); 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/p.delft-0.c: -------------------------------------------------------------------------------- 1 | if (P2 >= 0 && P2 <= 3 && P1 == P2) 2 | for (int c0 = 0; c0 <= min(2, -P2 + 4); c0 += 1) 3 | for (int c2 = (-P2 - c0 + 6) % 3; c2 <= 3; c2 += 3) 4 | s0(c0, c0, c2, c2); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/p6-0.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 5; c0 <= 8; c0 += 1) 3 | s0(c0); 4 | for (int c0 = 10; c0 <= 16; c0 += 2) 5 | s0(c0); 6 | for (int c0 = 20; c0 <= 25; c0 += 1) 7 | s0(c0); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/p6-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1] -> [In_1] : (In_1 >= 5 and In_1 <= 8) or (exists (e0 = [(In_1)/2]: 2e0 = In_1 and In_1 >= 10 and In_1 <= 16)) or (In_1 >= 20 and In_1 <= 25) } 2 | { : } 3 | { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/p6-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = -9; c0 <= 9; c0 += 1) 2 | for (int c1 = max(1, -c0 + 1); c1 <= min(10, -c0 + 10); c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/p6-1.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : In_2 >= 1 - In_1 and In_2 >= 1 and In_2 <= 10 - In_1 and In_2 <= 10 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride1-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 3; c0 <= 9; c0 += 3) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride1-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1] -> [In_1] : exists (e0 = [(In_1)/3]: 3e0 = In_1 and In_1 >= 3 and In_1 <= 9) } 2 | { : } 3 | { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride2-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= n; c0 += 32) 2 | for (int c1 = c0; c1 <= min(n, c0 + 31); c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride2-0.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(In_1)/32]: 32e0 = In_1 and In_2 <= 31 + In_1 and In_1 >= 0 and In_2 >= In_1 and In_2 <= n) } 2 | { : } 3 | [n] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride3-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 3; c0 <= n; c0 += 32) 2 | for (int c1 = c0; c1 <= min(n, c0 + 31); c1 += 1) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride3-0.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(-3 + In_1)/32]: 32e0 = -3 + In_1 and In_2 <= 31 + In_1 and In_1 >= 3 and In_2 >= In_1 and In_2 <= n) } 2 | { : } 3 | [n] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride4-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 18; c0 <= 98; c0 += 5) 2 | s0(c0); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride4-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1] -> [In_1] : exists (e0 = [(-3 + In_1)/5]: 5e0 = -3 + In_1 and In_1 >= 18 and In_1 <= 98) } 2 | { : } 3 | { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride5-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= min(100, -2 * n + 400); c0 += 2) 2 | for (int c1 = 2 * n + c0; c1 <= 400; c1 += 2) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride5-0.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(In_1)/2], e1 = [(In_2)/2]: 2e0 = In_1 and 2e1 = In_2 and In_1 >= 2 and In_1 <= 100 and In_2 <= 400 and In_2 >= 2n + In_1) } 2 | { : } 3 | [n] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride6-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 101; c0 += 1) 2 | for (int c1 = -((c0 - 1) % 2) + c0 + 1; c1 <= 400; c1 += 2) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride6-0.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(In_2)/2]: 2e0 = In_2 and In_1 >= 1 and In_2 >= In_1 and In_2 <= 400 and In_1 <= 101) } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride6-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 100; c0 += 2) 2 | for (int c1 = c0; c1 <= 400; c1 += 2) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride6-1.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(In_1)/2], e1 = [(In_2)/2]: 2e0 = In_1 and 2e1 = In_2 and In_1 >= 2 and In_2 >= In_1 and In_2 <= 400 and In_1 <= 100) } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride6-2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 2; c0 <= 100; c0 += 2) 2 | for (int c1 = c0; c1 <= 400; c1 += 2) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride6-2.in: -------------------------------------------------------------------------------- 1 | { s0[In_1, In_2] -> [In_1, In_2] : exists (e0 = [(In_1)/2], e1 = [(In_2)/2]: 2e0 = In_1 and 2e1 = In_2 and In_1 >= 2 and In_2 >= In_1 and In_2 <= 400 and In_1 <= 100) } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride7-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [4j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [j, i, 1] : i >= 1 and i <= 9 and j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 1; [i0, i1, i2] -> atomic[o0] : o0 <= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/stride7-1.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [4j, i, 0] : i >= 1 and i <= 9 and j >= 1 and j <= 9; s1[i, j] -> [j, i, 1] : i >= 1 and i <= 9 and j >= 1 and j <= 9 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 0; [i0, i1, i2] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 10; c0 += 1) 2 | for (int c1 = max(2 * c0 - 4, c0); c1 <= min(2 * c0, c0 + 6); c1 += 1) 3 | s0(2 * c0 - c1, -c0 + c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [i + j, i + 2j] : i >= 0 and i <= 4 and j >= 0 and j <= 6 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 14; c0 += 1) 2 | for (int c1 = max(2 * c0 - 12, -c0 + 3 * ((c0 + 1) / 2)); c1 <= min(2 * c0, c0 / 2 + 9); c1 += 3) 3 | s0((2 * c0 - c1) / 3, (-c0 + 2 * c1) / 3); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-1.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [2i + j, i + 2j] : i >= 0 and i <= 4 and j >= 0 and j <= 6 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = -3; c0 <= 96; c0 += 1) 2 | s0(c0, c0 + 4); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-2.in: -------------------------------------------------------------------------------- 1 | { s0[i, 4 + i] -> [i, 4 + i] : i >= -3 and i <= 96 } 2 | { : } 3 | { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-3.c: -------------------------------------------------------------------------------- 1 | s0(n + 19); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-3.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[19 + n] -> [19 + n] } 2 | { : } 3 | [n] -> { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-4.c: -------------------------------------------------------------------------------- 1 | s0(n + 1); 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/substitution-4.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i] -> [i] : exists (e0 = [(-1 - n + i)/18]: 18e0 = -1 - n + i and i <= 16 + n and i >= 1 + n) } 2 | { : } 3 | [n] -> { [i0] -> separate[o0] : o0 >= 0; [i0] -> atomic[o0] : o0 <= -1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/syr2k-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= min(n, 2 * b - 1); c0 += 1) 2 | for (int c1 = max(-n + 1, -b + 1); c1 <= min(b - c0, n - c0); c1 += 1) 3 | for (int c2 = max(1, c0 + c1); c2 <= min(n, n + c1); c2 += 1) 4 | s0(-c0 - c1 + c2 + 1, -c1 + c2, c2); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/syr2k-0.in: -------------------------------------------------------------------------------- 1 | [n, b] -> { s0[i, j, k] -> [1 - i + j, -j + k, k] : i >= 1 and j >= i and j <= n and k >= 1 and k <= n and k <= -1 + b + i and k >= 1 - b + j } 2 | { : } 3 | [n, b] -> { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/syr2k-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= min(n, 2 * b - 1); c0 += 1) 2 | for (int c1 = -b + 1; c1 <= b - c0; c1 += 1) 3 | for (int c2 = max(1, c0 + c1); c2 <= min(n, n + c1); c2 += 1) 4 | s0(-c0 - c1 + c2 + 1, -c1 + c2, c2); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/syr2k-1.in: -------------------------------------------------------------------------------- 1 | [n, b] -> { s0[i, j, k] -> [1 - i + j, -j + k, k] : i >= 1 and j >= i and j <= n and k >= 1 and k <= n and k <= -1 + b + i and k >= 1 - b + j } 2 | [b, n] -> { : b >= 1 and n >= b } 3 | [n, b] -> { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/syr2k-2.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= min(n, 2 * b - 1); c0 += 1) 2 | for (int c1 = max(-n + 1, -b + 1); c1 <= min(b - c0, n - c0); c1 += 1) 3 | for (int c2 = max(1, c0 + c1); c2 <= min(n, n + c1); c2 += 1) 4 | s0(-c0 - c1 + c2 + 1, -c1 + c2, c2); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/syr2k-2.in: -------------------------------------------------------------------------------- 1 | [n, b] -> { s0[i, j, k] -> [1 - i + j, -j + k, k] : i >= 1 and j >= i and j <= n and k >= 1 and k <= n and k <= -1 + b + i and k >= 1 - b + j } 2 | { : } 3 | [n, b] -> { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/syr2k-3.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= min(n, 2 * b - 1); c0 += 1) 2 | for (int c1 = -b + 1; c1 <= b - c0; c1 += 1) 3 | for (int c2 = max(1, c0 + c1); c2 <= min(n, n + c1); c2 += 1) 4 | s0(-c0 - c1 + c2 + 1, -c1 + c2, c2); 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/syr2k-3.in: -------------------------------------------------------------------------------- 1 | [n, b] -> { s0[i, j, k] -> [1 - i + j, -j + k, k] : i >= 1 and j >= i and j <= n and k >= 1 and k <= n and k <= -1 + b + i and k >= 1 - b + j } 2 | [b, n] -> { : b >= 1 and n >= b } 3 | [n, b] -> { [i0, i1, i2] -> separate[o0] : o0 >= 2; [i0, i1, i2] -> atomic[o0] : o0 <= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/ts1d-orig0-0.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c1 = 0; c1 < N; c1 += 1) 3 | s0(1, c1, 1, 0, 0); 4 | for (int c1 = 0; c1 < T; c1 += 1) { 5 | for (int c3 = 0; c3 < N; c3 += 1) 6 | s1(2, c1, 0, c3, 1); 7 | for (int c3 = 1; c3 < N - 1; c3 += 1) 8 | s2(2, c1, 1, c3, 1); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/wak1-0.in: -------------------------------------------------------------------------------- 1 | [a3, b3, a2, b2, a1, b1] -> { s2[i] -> [i, 2] : i >= a3 and i <= b3; s0[i] -> [i, 0] : i >= a1 and i <= b1; s1[i] -> [i, 1] : i >= a2 and i <= b2 } 2 | { : } 3 | [a1, b1] -> { [i0, i1] -> separate[o0] : o0 >= 2 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/wak1-1.in: -------------------------------------------------------------------------------- 1 | [a3, b3, a2, b2, a1, b1] -> { s2[i] -> [i, 2] : i >= a3 and i <= b3; s0[i] -> [i, 0] : i >= a1 and i <= b1; s1[i] -> [i, 1] : i >= a2 and i <= b2 } 2 | { : } 3 | [a1, b1] -> { [i0, i1] -> separate[o0] : o0 >= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/wak2-0.in: -------------------------------------------------------------------------------- 1 | [a2, b2, c2, d2, a1, b1, c1, d1] -> { s0[i, j] -> [i, j, 0] : i >= a1 and i <= b1 and j >= c1 and j <= d1; s1[i, j] -> [i, j, 1] : i >= a2 and i <= b2 and j >= c2 and j <= d2 } 2 | { : } 3 | [a1, b1, c1, d1] -> { [i0, i1, i2] -> separate[o0] : o0 >= 2 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/wak2-1.in: -------------------------------------------------------------------------------- 1 | [a2, b2, c2, d2, a1, b1, c1, d1] -> { s0[i, j] -> [i, j, 0] : i >= a1 and i <= b1 and j >= c1 and j <= d1; s1[i, j] -> [i, j, 1] : i >= a2 and i <= b2 and j >= c2 and j <= d2 } 2 | { : } 3 | [a1, b1, c1, d1] -> { [i0, i1, i2] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/wak3-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = a; c0 <= b + 20; c0 += 1) { 2 | if (b >= c0) 3 | s0(c0); 4 | if (c0 >= a + 10 && b + 10 >= c0) 5 | s1(c0); 6 | if (c0 >= a + 20) 7 | s2(c0); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/wak3-0.in: -------------------------------------------------------------------------------- 1 | [a, b] -> { s2[i] -> [i, 2] : i >= 20 + a and i <= 20 + b; s0[i] -> [i, 0] : i >= a and i <= b; s1[i] -> [i, 1] : i >= 10 + a and i <= 10 + b } 2 | { : } 3 | [a, b] -> { [i0, i1] -> atomic[o0] : o0 <= 0; [i0, i1] -> separate[o0] : o0 >= 1 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/wak3-1.in: -------------------------------------------------------------------------------- 1 | [a, b] -> { s2[i] -> [i, 2] : i >= 20 + a and i <= 20 + b; s0[i] -> [i, 0] : i >= a and i <= b; s1[i] -> [i, 1] : i >= 10 + a and i <= 10 + b } 2 | { : } 3 | [a, b] -> { [i0, i1] -> atomic[o0] : o0 <= -1; [i0, i1] -> separate[o0] : o0 >= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/wak4-0.c: -------------------------------------------------------------------------------- 1 | for (int c0 = max(max(max(max(a1, a2), a3), a4), a5); c0 <= min(min(min(min(b1, b2), b3), b4), b5); c0 += 1) { 2 | s0(c0); 3 | s1(c0); 4 | } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/wak4-1.c: -------------------------------------------------------------------------------- 1 | for (int c0 = max(max(max(max(a1, a2), a3), a4), a5); c0 <= min(min(min(min(b1, b2), b3), b4), b5); c0 += 1) { 2 | s0(c0); 3 | s1(c0); 4 | } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/x-0.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [8 - i + j, i, 0] : i >= 1 and i <= 8 and j >= 1 and j <= 4; s1[i, j] -> [-1 + i + j, i, 1] : i >= 1 and i <= 8 and j >= 1 and j <= 4 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 1; [i0, i1, i2] -> atomic[o0] : o0 <= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/omega/x-1.in: -------------------------------------------------------------------------------- 1 | { s0[i, j] -> [8 - i + j, i, 0] : i >= 1 and i <= 8 and j >= 1 and j <= 4; s1[i, j] -> [-1 + i + j, i, 1] : i >= 1 and i <= 8 and j >= 1 and j <= 4 } 2 | { : } 3 | { [i0, i1, i2] -> separate[o0] : o0 >= 1; [i0, i1, i2] -> atomic[o0] : o0 <= 0 } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/README: -------------------------------------------------------------------------------- 1 | These examples are taken from the "Polyhedra Scanning Revisited" paper 2 | by Chun Chen. 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/figure7_b.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 100; c0 += 1) { 2 | if (n >= 2) 3 | s0(c0); 4 | for (int c1 = 1; c1 <= 100; c1 += 1) { 5 | s2(c0, c1); 6 | if (n >= 2) 7 | s1(c0, c1); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/figure7_b.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i] -> [i,0] : 1 <= i <= 100 and n > 1; 2 | s1[i,j] -> [i,j] : 1 <= i,j <= 100 and n > 1; 3 | s2[i,j] -> [i,j] : 1 <= i,j <= 100 } 4 | [n] -> { : } 5 | [n] -> { [i,j] -> separate[x] : x >= 2 } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/figure7_c.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= 100; c0 += 1) { 2 | if (n >= 2) { 3 | s0(c0); 4 | for (int c1 = 1; c1 <= 100; c1 += 1) { 5 | s2(c0, c1); 6 | s1(c0, c1); 7 | } 8 | } else { 9 | for (int c1 = 1; c1 <= 100; c1 += 1) 10 | s2(c0, c1); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/figure7_c.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i] -> [i,0] : 1 <= i <= 100 and n > 1; 2 | s1[i,j] -> [i,j] : 1 <= i,j <= 100 and n > 1; 3 | s2[i,j] -> [i,j] : 1 <= i,j <= 100 } 4 | [n] -> { : } 5 | [n] -> { [i,j] -> separate[x] : x >= 1 } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/figure7_d.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i] -> [i,0] : 1 <= i <= 100 and n > 1; 2 | s1[i,j] -> [i,j] : 1 <= i,j <= 100 and n > 1; 3 | s2[i,j] -> [i,j] : 1 <= i,j <= 100 } 4 | [n] -> { : } 5 | [n] -> { [i,j] -> separate[x] : x >= 0 } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/figure8_a.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 <= n; c0 += 4) 2 | for (int c1 = c0; c1 <= n; c1 += 3) 3 | s0(c0, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/figure8_a.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i,j] -> [i,j] : exists alpha, beta: 1 <= i <= n and i <= j <= n and 2 | i = 1 + 4 alpha and j = i + 3 beta} 3 | [n] -> { : } 4 | [n] -> {} 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/figure8_b.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 2; c0 < n - 1; c0 += 4) { 3 | s1(c0); 4 | s0(c0 + 2); 5 | } 6 | if (n >= 1 && n % 4 >= 2) 7 | s1(-(n % 4) + n + 2); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/pldi2012/figure8_b.in: -------------------------------------------------------------------------------- 1 | [n] -> { s0[i] -> [i] : exists alpha: 1 <= i <= n and i = 4 alpha; 2 | s1[i] -> [i] : exists alpha: 1 <= i <= n and i = 4 alpha + 2 } 3 | [n] -> { : } 4 | [n] -> { } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/separate.c: -------------------------------------------------------------------------------- 1 | { 2 | a(0); 3 | for (int c0 = 1; c0 <= 9; c0 += 1) { 4 | a(c0); 5 | b(c0 - 1); 6 | } 7 | b(9); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/separate.in: -------------------------------------------------------------------------------- 1 | { a[i] -> [i, 0] : 0 <= i < 10; b[i] -> [i+1, 1] : 0 <= i < 10 } 2 | { : } 3 | { [i, d] -> separate[x] } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/separate.st: -------------------------------------------------------------------------------- 1 | domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }" 2 | child: 3 | schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]" 4 | options: "{ separate[x] }" 5 | child: 6 | sequence: 7 | - filter: "{ a[i] }" 8 | - filter: "{ b[i] }" 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/separation_class.in: -------------------------------------------------------------------------------- 1 | { A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and i + j <= 100 } 2 | { : } 3 | { [a,b,c,d] -> separation_class[[0]->[0]] : 4 | exists b': 0 <= 10a,10b' and 10a+9+10b'+9 <= 100; 5 | [a,b,c,d] -> separation_class[[1]->[0]] : 6 | 0 <= 10a,10b and 10a+9+10b+9 <= 100 } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/separation_class2.in: -------------------------------------------------------------------------------- 1 | [n] -> { A[i,j] -> [it,jt, ip, jp] : 0 <= i,j < n and ip = i % 8 and it = i - ip and jp = j % 8 and jt = j - jp} 2 | [n] -> { : n >= 10} 3 | [n] -> { [it, jt, ip, jp] -> separation_class[[x]->[1]]: (exists id, jd: 0 <= x <= 3 and it < n - id and jt < n - jd and id = n %8 and jd = n %8)} 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/shift.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 9; c0 += 1) { 2 | A(c0); 3 | B(c0); 4 | } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/shift.in: -------------------------------------------------------------------------------- 1 | { A[i] -> [2i]: 0 <= i < 10; B[i] -> [2i+1] : 0 <= i < 10 } 2 | { : } 3 | { } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/shift_unroll.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 9; c0 += 1) { 2 | A(c0, 0); 3 | A(c0, 1); 4 | A(c0, 2); 5 | A(c0, 3); 6 | A(c0, 4); 7 | A(c0, 5); 8 | A(c0, 6); 9 | A(c0, 7); 10 | A(c0, 8); 11 | A(c0, 9); 12 | for (int c2 = 0; c2 <= 9; c2 += 1) 13 | B(c0, c2); 14 | } 15 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/shift_unroll.in: -------------------------------------------------------------------------------- 1 | { A[i,j] -> [2i,0,j]: 0 <= i,j < 10; B[i,j] -> [2i+1,1,j] : 0 <= i,j < 10 } 2 | { : } 3 | { [i,0,j] -> unroll[2] } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/single_valued.c: -------------------------------------------------------------------------------- 1 | if (2 * ((t1 - 1) % 64) + 8 >= t1) 2 | S(-(2 * ((t1 - 1) % 64)) + t1 + 126); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/single_valued.in: -------------------------------------------------------------------------------- 1 | # Check that isl recognizes that the inverse schedule is single-valued 2 | # and does not end up in an infinite recursion. 3 | [t1] -> {S[c2] -> [c2]: t1 <= c2 <= 134 and (c2+t1) % 128 = 0 and c2 > 0} 4 | [t1] -> {: t1 > 0} 5 | [t1] -> {} 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/sor1d-part.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 1; c0 < max((6 * M + 3 * N + 188) / 200 - 2, (N + 93) / 100 + 3 * ((2 * M + N - 4) / 200) - 1); c0 += 1) 2 | for (int c1 = max(0, floord(-N + 100 * c0 + 106, 300)); c1 <= min((2 * M + N - 4) / 200 - 1, (c0 - 1) / 3); c1 += 1) 3 | S2(c0 - c1, c1); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/stride.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 100; c0 += 2) { 2 | for (int c3 = 0; c3 <= 100; c3 += 1) 3 | A(c0, c3); 4 | for (int c2 = 0; c2 <= 100; c2 += 1) 5 | B(c0, c2); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/stride.in: -------------------------------------------------------------------------------- 1 | # Check that we find a common stride on the first dimension 2 | # even if it is imposed by different inner dimensions 3 | { A[i,k] -> [i,0,j,k] : 0 <= i,k <= 100 and i = 2 j; 4 | B[i,k] -> [i,1,k,j] : 0 <= i,k <= 100 and i = 2 j } 5 | { : } 6 | { } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/stride5.c: -------------------------------------------------------------------------------- 1 | if (n % 2 == 0) 2 | for (int c0 = (-n / 2) + 2 * floord(n - 1, 4) + 2; c0 <= 100; c0 += 2) 3 | S(c0); 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/stride5.in: -------------------------------------------------------------------------------- 1 | [n] -> { S[t] -> [t] : exists e : 2 t - n = 4e and 0 <= t <= 100 } 2 | [n] -> { : } 3 | { } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/stride7.c: -------------------------------------------------------------------------------- 1 | { 2 | for (int c0 = 2; c0 <= 100; c0 += 64) 3 | for (int c2 = c0 - 1; c2 <= 120; c2 += 1) 4 | s2(c0, c2); 5 | for (int c0 = 66; c0 <= 200; c0 += 64) 6 | for (int c2 = 122; c2 <= c0 + 62; c2 += 1) 7 | s4(c0, c2); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll.c: -------------------------------------------------------------------------------- 1 | { 2 | A(0); 3 | A(100000000); 4 | A(200000000); 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll.in: -------------------------------------------------------------------------------- 1 | # Test that unrolling takes into account stride constraints. 2 | # If it didn't, it would run essentially forever on this example. 3 | [n] -> { A[i] -> [i] : exists a : i = 100000000 a and 0 <= a <= 2 } 4 | {:} 5 | { [i] -> unroll[0] } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll10.in: -------------------------------------------------------------------------------- 1 | # Check that all information is taken into account while trying to unroll 2 | [m,n] -> { A[i] -> [i] : 0 <= i < n,m } 3 | [m,n] -> { : m <= 10 or n <= 10 } 4 | { [i] -> unroll[x] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll10.st: -------------------------------------------------------------------------------- 1 | # Check that all information is taken into account while trying to unroll 2 | domain: "[m,n] -> { A[i] : 0 <= i < n,m }" 3 | child: 4 | context: "[m,n] -> { [] : m <= 10 or n <= 10 }" 5 | child: 6 | schedule: "[{ A[i] -> [i] }]" 7 | options: "{ unroll[x] }" 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll11.c: -------------------------------------------------------------------------------- 1 | { 2 | if (t1 >= 126) 3 | S(0, t1 - 384); 4 | S(0, t1 - 256); 5 | if (t1 >= 126) 6 | S(1, t1 - 384); 7 | S(1, t1 - 256); 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll2.c: -------------------------------------------------------------------------------- 1 | { 2 | A(0); 3 | A(1); 4 | A(2); 5 | A(3); 6 | for (int c0 = 4; c0 <= 99996; c0 += 1) 7 | A(c0); 8 | A(99997); 9 | A(99998); 10 | A(99999); 11 | } 12 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll2.in: -------------------------------------------------------------------------------- 1 | # Check that the different disjuncts in the unroll option 2 | # are handled separately. 3 | { A[i] -> [i] : 0 <= i < 100000 } 4 | { : } 5 | { [i] -> unroll[0] : i < 4 or i > 99996 } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll3.c: -------------------------------------------------------------------------------- 1 | if ((t1 + 121) % 128 <= 123) 2 | write_shared_A(((t1 + 121) % 128) + 1); 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll7.c: -------------------------------------------------------------------------------- 1 | { 2 | S(0, 0); 3 | S(0, 3); 4 | S(0, 4); 5 | S(1, 1); 6 | S(1, 4); 7 | S(2, 2); 8 | S(3, 3); 9 | S(4, 4); 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll7.in: -------------------------------------------------------------------------------- 1 | # Check that some code is generated. 2 | # Older versions of isl would abort on unknown divs. 3 | { S[i,j] -> [i,j]: exists (alpha, beta: j=i+4alpha +3beta and 0 <= alpha < 24 and 0 <= beta and 0 <= i,j < 5) } 4 | { : } 5 | { [i,j] -> unroll[x] } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll8.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 99; c0 += 1) { 2 | A(c0, 0); 3 | A(c0, 1); 4 | B(c0, 0); 5 | B(c0, 1); 6 | } 7 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll8.st: -------------------------------------------------------------------------------- 1 | # Check that options are adjusted by shifted stride detection 2 | domain: "{ A[i,j] : 0 <= i < 100 and 0 <= j < 2; B[i,j] : 0 <= i < 100 and 0 <= j < 2 }" 3 | child: 4 | schedule: "[{ A[i,j] -> [2i]; B[i,j] -> [2i+1] }, { A[i,j] -> [j]; B[i,j] -> [j]}]" 5 | options: "{ unroll[1] }" 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/codegen/unroll9.c: -------------------------------------------------------------------------------- 1 | for (int c0 = 0; c0 <= 99; c0 += 1) 2 | for (int c1 = 0; c1 <= 99; c1 += 1) { 3 | A(c1, 0, c0); 4 | A(c1, 1, c0); 5 | B(c1, 0, c0); 6 | B(c1, 1, c0); 7 | } 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex0.polylib: -------------------------------------------------------------------------------- 1 | 2 3 2 | 1 1 0 3 | 1 -1 1 4 | 5 | 2 3 6 | 1 1 -1 7 | 1 -1 2 8 | 9 | 2 3 10 | 1 1 0 11 | 1 -1 2 12 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex1.polylib: -------------------------------------------------------------------------------- 1 | # {j,N | 0<=j<=N-1; 2<=N} 2 | 4 4 3 | 1 1 0 0 4 | 1 -1 1 -1 5 | 1 0 1 -2 6 | 1 0 0 1 7 | # {j, N | 1<=j<=N; 1<=N} 8 | 4 4 9 | 1 1 0 -1 10 | 1 -1 1 0 11 | 1 0 1 -1 12 | 1 0 0 1 13 | # {j,N | 0<=j<=N; 2<=j+N} 14 | 3 4 15 | 1 1 1 -2 16 | 1 1 0 0 17 | 1 -1 1 0 18 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex10.polylib: -------------------------------------------------------------------------------- 1 | 3 4 2 | 1 54 1 -4 3 | 1 2 -1 58 4 | 1 0 -1 6 5 | 6 | 4 4 7 | 1 54 1 -4 8 | 1 2 -1 58 9 | 1 0 1 -7 10 | 1 -4 1 0 11 | 12 | 4 4 13 | 1 54 1 -4 14 | 1 2 -1 58 15 | 1 0 -1 116 16 | 1 0 0 1 17 | 18 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex11.polylib: -------------------------------------------------------------------------------- 1 | 3 4 2 | 1 0 -1 6 3 | 1 -1 1 1 4 | 1 1 1 -10 5 | 6 | 3 4 7 | 1 1 0 -4 8 | 1 -1 -1 8 9 | 1 -1 1 1 10 | 11 | 3 4 12 | 1 0 -1 6 13 | 1 1 0 -4 14 | 1 -1 1 1 15 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex12.polylib: -------------------------------------------------------------------------------- 1 | 3 5 2 | 1 0 0 1 1 3 | 1 0 1 0 1 4 | 1 -1 -1 0 -2 5 | 6 | 3 5 7 | 1 0 0 1 2 8 | 1 1 -1 0 0 9 | 1 1 0 0 -1 10 | 11 | 1 5 12 | 1 0 0 1 2 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex14.polylib: -------------------------------------------------------------------------------- 1 | 3 4 2 | 0 1 0 2 3 | 1 0 1 0 4 | 1 0 -1 2 5 | 6 | 3 4 7 | 1 1 0 0 8 | 1 0 1 0 9 | 1 0 -1 2 10 | 11 | 3 4 12 | 1 1 0 2 13 | 1 0 1 0 14 | 1 0 -1 2 15 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex3.polylib: -------------------------------------------------------------------------------- 1 | 1 4 2 | 1 1 1 -6 3 | 4 | 3 4 5 | 1 1 1 -3 6 | 1 1 0 -5 7 | 1 -1 0 10 8 | 9 | 1 4 10 | 1 1 1 -3 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex4.polylib: -------------------------------------------------------------------------------- 1 | 1 4 2 | 1 1 1 -6 3 | 4 | 2 4 5 | 0 1 0 -1 6 | 0 0 1 -4 7 | 8 | 1 4 9 | 1 1 1 -5 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex5.polylib: -------------------------------------------------------------------------------- 1 | 2 4 2 | 0 1 0 -2 3 | 0 0 1 -6 4 | 5 | 2 4 6 | 0 1 0 -1 7 | 0 0 1 -4 8 | 9 | 3 4 10 | 0 -2 1 -2 11 | 1 1 0 -1 12 | 1 -1 0 2 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex6.polylib: -------------------------------------------------------------------------------- 1 | 3 4 2 | 1 1 1 -2 3 | 1 -1 1 2 4 | 1 0 -1 2 5 | 6 | 3 4 7 | 1 0 1 -1 8 | 1 1 -1 1 9 | 1 -1 -1 5 10 | 11 | 6 4 12 | 1 -1 0 4 13 | 1 1 0 0 14 | 1 1 2 -2 15 | 1 -1 2 2 16 | 1 1 -2 4 17 | 1 -1 -2 8 18 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex7.polylib: -------------------------------------------------------------------------------- 1 | 1 4 2 | 0 0 1 0 3 | 4 | 2 4 5 | 1 1 -1 1 6 | 1 -1 -1 1 7 | 8 | 1 4 9 | 1 0 -1 1 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/convex9.polylib: -------------------------------------------------------------------------------- 1 | 4 4 2 | 1 1 0 0 3 | 1 -1 0 1 4 | 1 0 1 0 5 | 1 0 -1 10 6 | 7 | 2 4 8 | 1 1 0 -10 9 | 0 0 -1 5 10 | 11 | 3 4 12 | 1 1 0 0 13 | 1 0 1 0 14 | 1 0 -1 10 15 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/devos.pwqp: -------------------------------------------------------------------------------- 1 | [U] -> { [i0] -> ((1/3 * U + 2/3 * i0) - [(U + 2i0)/3]) : 2i0 >= -3 - U and 2i0 <= -U and U >= 0 and U <= 10 } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/equality1.pwqp: -------------------------------------------------------------------------------- 1 | [n] -> { [x] -> 1 + [(x+1)/3] : exists a : x = 3a +1 && 0 <= x <= n } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/equality2.pwqp: -------------------------------------------------------------------------------- 1 | [n] -> { [x,y] -> x^2 * y : n = 2x + 4y and 0 <= x,y <= 10 } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/equality3.pwqp: -------------------------------------------------------------------------------- 1 | [m,n] -> { [x,y] -> x^2 * y : n = 2x + 4y and 0 <= x,y <= 10 and 3 n = 5 m } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/equality4.pwqp: -------------------------------------------------------------------------------- 1 | [m,n] -> { [x,y] -> x^2 * y + m + 13 * n: n = 2x + 4y and 0 <= x,y <= 10 and 3 n = 5 m } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/equality5.pwqp: -------------------------------------------------------------------------------- 1 | [m,n] -> { [x,y,z] -> x^2 * y + z + m + 13 * n: n = 2x + 4y and 0 <= x,y <= 10 and 3 n = 5 m and z = x + y } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/ex.pip: -------------------------------------------------------------------------------- 1 | 1 5 2 | 1 -1 1 1 0 3 | 4 | -1 5 | 6 | 3 7 7 | 1 0 -1 0 1 0 0 8 | 1 -1 0 0 0 1 0 9 | 1 1 1 -1 0 0 0 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/ex2.pip: -------------------------------------------------------------------------------- 1 | 1 5 2 | 1 -1 1 1 0 3 | 4 | -1 5 | 6 | 3 7 7 | 1 0 -1 0 1 0 0 8 | 1 -1 0 0 0 1 0 9 | 1 1 1 -1 0 0 0 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/exist.pip: -------------------------------------------------------------------------------- 1 | [n] -> { : n mod 2 = 0 } 2 | 3 | -1 4 | 5 | [n] -> { [i] : n <= i } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/exist2.pip: -------------------------------------------------------------------------------- 1 | [n, a, b] -> { : exists e : 1 <= a <= 7e and 9e <= b <= n } 2 | 3 | -1 4 | 5 | [n, a, b] -> { [i] : n <= 2i } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/faddeev.pwqp: -------------------------------------------------------------------------------- 1 | [N] -> { [i, j, k] -> (((4 + 6 * N + 2 * N^2) + (-2 - 2 * N) * j) + ((-2 - N) + j) * k) : j = 1 + i and k = 1 + i and i >= 3 and N <= 100 and i <= N and N >= 10 } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/fimmel.pip: -------------------------------------------------------------------------------- 1 | 0 4 2 | 3 | -1 4 | 5 | 7 6 6 | 1 2 6 0 0 -9 7 | 1 5 -3 0 0 0 8 | 1 2 -10 0 0 15 9 | 1 -2 6 0 0 -3 10 | 1 -2 -6 0 0 17 11 | 1 0 1 -1 0 0 12 | 1 1 0 0 -1 0 13 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | must_source: "{ T[i] -> a[] : 0 <= i <= 9 }" 3 | kill: "{ T[9] -> a[] }" 4 | schedule: 5 | domain: "{ T[i]; S[] }" 6 | child: 7 | sequence: 8 | - filter: "{ T[i] }" 9 | child: 10 | schedule: "[{ T[i] -> [(i)] }]" 11 | - filter: "{ S[] }" 12 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[i] -> a[] : 0 <= i < 10 } 3 | kill: { T[9] -> a[] } 4 | schedule_map: { T[i] -> [0,i]; S[] -> [1,0] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop2-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop2.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[i] -> a[] : 0 <= i < 10 } 3 | kill: { K[] -> a[] } 4 | schedule_map: { T[i] -> [0,i]; K[] -> [0,10]; S[] -> [1,0] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop2.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop3-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop3.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[i] -> a[] : 0 <= i < 10 } 3 | kill: { K[] -> a[] } 4 | schedule_map: { T[i] -> [0,i]; K[] -> [0,9]; S[] -> [1,0] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_loop3.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | may_source: "{ T[i] -> a[] : 0 <= i <= 9 }" 3 | kill: "{ T[4] -> a[] }" 4 | schedule: 5 | domain: "{ T[i]; S[] }" 6 | child: 7 | sequence: 8 | - filter: "{ T[i] }" 9 | child: 10 | schedule: "[{ T[i] -> [(i)] }]" 11 | - filter: "{ S[] }" 12 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i] -> [S[] -> a[]] : 4 <= i <= 9 }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | may_source: { T[i] -> a[] : 0 <= i < 10 } 3 | kill: { T[4] -> a[] } 4 | schedule_map: { T[i] -> [0,i]; S[] -> [1,0] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i] -> [S[] -> a[]] : 4 <= i <= 9 }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop2-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | may_source: "{ T[i] -> a[] : 0 <= i <= 9 }" 3 | kill: "{ T[9] -> a[] }" 4 | schedule: 5 | domain: "{ T[i]; S[] }" 6 | child: 7 | sequence: 8 | - filter: "{ T[i] }" 9 | child: 10 | schedule: "[{ T[i] -> [(i)] }]" 11 | - filter: "{ S[] }" 12 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop2-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop2.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | may_source: { T[i] -> a[] : 0 <= i < 10 } 3 | kill: { T[9] -> a[] } 4 | schedule_map: { T[i] -> [0,i]; S[] -> [1,0] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop2.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop3-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i] -> [S[] -> a[]] : 4 <= i <= 9 }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop3.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | may_source: { T[i] -> a[] : 0 <= i < 10 } 3 | kill: { K[] -> a[] } 4 | schedule_map: { T[i] -> [0,i]; K[] -> [0,4]; S[] -> [1,0] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/kill_may_loop3.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i] -> [S[] -> a[]] : 4 <= i <= 9 }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/loop-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | must_source: "{ T[i] -> a[] : 0 <= i <= 9 }" 3 | schedule: 4 | domain: "{ T[i]; S[] }" 5 | child: 6 | sequence: 7 | - filter: "{ T[i] }" 8 | child: 9 | schedule: "[{ T[i] -> [(i)] }]" 10 | - filter: "{ S[] }" 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/loop-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/loop.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[i] -> a[] : 0 <= i < 10 } 3 | schedule_map: { T[i] -> [0,i]; S[] -> [1,0] } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/loop.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/may_loop-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | may_source: "{ T[i] -> a[] : 0 <= i <= 9 }" 3 | schedule: 4 | domain: "{ T[i]; S[] }" 5 | child: 6 | sequence: 7 | - filter: "{ T[i] }" 8 | child: 9 | schedule: "[{ T[i] -> [(i)] }]" 10 | - filter: "{ S[] }" 11 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/may_loop-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i] -> [S[] -> a[]] : 0 <= i <= 9 }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ S[] -> a[] }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/may_loop.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | may_source: { T[i] -> a[] : 0 <= i < 10 } 3 | schedule_map: { T[i] -> [0,i]; S[] -> [1,0] } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/may_loop.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i] -> [S[] -> a[]] : 0 <= i <= 9 }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ S[] -> a[] }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/mixed_loop-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]]; T[i = 8] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/mixed_loop.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[i] -> a[] : 0 <= i < 10 and i mod 2 = 0 } 3 | may_source: { T[i] -> a[] : 0 <= i < 10 and i mod 2 = 1 } 4 | schedule_map: { T[i] -> [0,i]; S[] -> [1,0] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/mixed_loop.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[i = 9] -> [S[] -> a[]]; T[i = 8] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ [S_1[] -> __pet_ref_2[]] -> [[S_2[] -> __pet_ref_4[]] -> a[]]; [S_1[] -> __pet_ref_1[]] -> [[S_2[] -> __pet_ref_4[]] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | must_source: "{ T[] -> a[]; U[] -> a[] }" 3 | schedule: 4 | domain: "{ U[]; S[]; T[] }" 5 | child: 6 | sequence: 7 | - filter: "{ T[]; U[] }" 8 | - filter: "{ S[] }" 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[] -> a[]; U[] -> a[] } 3 | schedule_map: { T[] -> [0]; U[] -> [0]; S[] -> [1] } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source2-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | must_source: "{ T[] -> a[] }" 3 | may_source: "{ U[] -> a[] }" 4 | schedule: 5 | domain: "{ U[]; S[]; T[] }" 6 | child: 7 | sequence: 8 | - filter: "{ T[]; U[] }" 9 | - filter: "{ S[] }" 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source2-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source2.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[] -> a[] } 3 | may_source: { U[] -> a[] } 4 | schedule_map: { T[] -> [0]; U[] -> [0]; S[] -> [1] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source2.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source3-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]]; V[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source3.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[] -> a[]; U[] -> a[] } 3 | may_source: { V[] -> a[] } 4 | schedule_map: { T[] -> [0,0]; U[] -> [0,0]; V[] -> [0,1]; S[] -> [1,0] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source3.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]]; U[] -> [S[] -> a[]]; V[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source4-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]]; V[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source4.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[] -> a[]; U[] -> a[] } 3 | may_source: { V[] -> a[] } 4 | schedule_map: { T[] -> [0,1]; U[] -> [0,0]; V[] -> [0,1]; S[] -> [1,0] } 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/multi_source4.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]]; V[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/no_source-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | schedule: 3 | domain: "{ S[] }" 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/no_source-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ }" 3 | must_no_source: "{ S[] -> a[] }" 4 | may_no_source: "{ S[] -> a[] }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/no_source.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | schedule_map: { S[] -> [] } 3 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/no_source.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ }" 3 | must_no_source: "{ S[] -> a[] }" 4 | may_no_source: "{ S[] -> a[] }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/no_source2-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | must_source: "{ T[] -> a[] }" 3 | schedule: 4 | domain: "{ S[]; T[] }" 5 | child: 6 | sequence: 7 | - filter: "{ S[] }" 8 | - filter: "{ T[] }" 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/no_source2-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ }" 3 | must_no_source: "{ S[] -> a[] }" 4 | may_no_source: "{ S[] -> a[] }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/no_source2.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[] -> a[] } 3 | schedule_map: { T[] -> [1]; S[] -> [0] } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/no_source2.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ }" 3 | must_no_source: "{ S[] -> a[] }" 4 | may_no_source: "{ S[] -> a[] }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/single_may_source-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | may_source: "{ T[] -> a[] }" 3 | schedule: 4 | domain: "{ S[]; T[] }" 5 | child: 6 | sequence: 7 | - filter: "{ T[] }" 8 | - filter: "{ S[] }" 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/single_may_source-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ S[] -> a[] }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/single_may_source.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | may_source: { T[] -> a[] } 3 | schedule_map: { T[] -> [0]; S[] -> [1] } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/single_may_source.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ }" 2 | may_dependence: "{ T[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ S[] -> a[] }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/single_source-tree.ai: -------------------------------------------------------------------------------- 1 | sink: "{ S[] -> a[] }" 2 | must_source: "{ T[] -> a[] }" 3 | schedule: 4 | domain: "{ S[]; T[] }" 5 | child: 6 | sequence: 7 | - filter: "{ T[] }" 8 | - filter: "{ S[] }" 9 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/single_source-tree.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ T[] -> [S[] -> a[]] }" 2 | may_dependence: "{ T[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/single_source.ai: -------------------------------------------------------------------------------- 1 | sink: { S[] -> a[] } 2 | must_source: { T[] -> a[] } 3 | schedule_map: { T[] -> [0]; S[] -> [1] } 4 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/flow/single_source.flow: -------------------------------------------------------------------------------- 1 | must_dependence: "{ T[] -> [S[] -> a[]] }" 2 | may_dependence: "{ T[] -> [S[] -> a[]] }" 3 | must_no_source: "{ }" 4 | may_no_source: "{ }" 5 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/gist1.polylib: -------------------------------------------------------------------------------- 1 | 4 5 2 | 0 1 0 0 -1 3 | 0 0 1 0 1 4 | 0 0 0 1 -3 5 | 1 0 0 0 1 6 | 7 | 4 5 8 | 0 1 0 0 -1 9 | 0 0 1 1 -2 10 | 1 0 0 1 0 11 | 1 0 0 -1 3 12 | 13 | 1 5 14 | 0 0 1 0 1 15 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/linearExample.pwqp: -------------------------------------------------------------------------------- 1 | [N, M, L] -> { [i, j, k] -> ((1/2 * i + 5 * j) + 1/7 * k) : i >= 0 and k >= -N + i and k >= -M - j and j <= L + i and L >= 0 and L >= -M } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/max.pip: -------------------------------------------------------------------------------- 1 | 0 3 2 | 3 | -1 4 | 5 | 4 5 6 | 1 -1 0 1 0 7 | 1 0 -1 1 0 8 | 1 -1 3 -2 12 9 | 1 2 -1 -1 3 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/neg.pwqp: -------------------------------------------------------------------------------- 1 | [n] -> { [i0] -> i0^2 : i0 >= -20 - n and i0 <= n and i0 <= -1 and n >= 0 } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/negative.pip: -------------------------------------------------------------------------------- 1 | 1 3 2 | # n 1 3 | 1 1 -1 # n >= 1 4 | -1 5 | 6 | 2 4 7 | # i n 1 8 | 1 1 0 1 # i >= -1 9 | 1 -1 1 0 # i <= n 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/philippe.pwqp: -------------------------------------------------------------------------------- 1 | [N] -> { [i, j] -> ((1/2 * i + 1/2 * i^2) + j) : i <= N and j >= 0 and j <= i } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/philippe3vars.pwqp: -------------------------------------------------------------------------------- 1 | [N] -> { [i, j, k] -> (((1/2 * i + 1/2 * i^2) + j) + k^3) : i >= 0 and k >= -N + i and k >= -j and j <= i } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/philippe3vars3pars.pwqp: -------------------------------------------------------------------------------- 1 | [N, M, L] -> { [i, j, k] -> (((1/2 * i + 1/2 * i^2) + j) + k^3) : i >= 0 and k >= -N + i and k >= -M - j and j <= L + i and L >= 0 and L >= -M } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/philippeNeg.pwqp: -------------------------------------------------------------------------------- 1 | [N] -> { [i, j] -> ((1/2 * i + 1/2 * i^2) + j) : i <= N and j >= -1 and j <= i } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/philippePolynomialCoeff.pwqp: -------------------------------------------------------------------------------- 1 | [N, M] -> { [i, j] -> ((N * i + (1/5 * N + N^2) * i^2) + 5 * j) : i <= N and j >= 0 and j <= i and M >= 0 } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/philippePolynomialCoeff1P.pwqp: -------------------------------------------------------------------------------- 1 | [N] -> { [i, j] -> ((N * i + (1/5 * N + N^2) * i^2) + 5 * j) : i <= N and j >= 0 and j <= i } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/product.pwqp: -------------------------------------------------------------------------------- 1 | [N] -> { [i0, i1, i2] -> (i0^3 * i1^2 + N * i1 * i2) : i0 >= 0 and i0 <= N and i1 >= 0 and i1 <= N and i2 >= 0 and i2 <= N } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/schedule/carry_bounded_coefficients.st: -------------------------------------------------------------------------------- 1 | domain: "{ C[i0, i1] : 2 <= i0 <= 3999 and 0 <= i1 < i0 }" 2 | child: 3 | schedule: "[{ C[i0, i1] -> [(i0)] }]" 4 | child: 5 | schedule: "[{ C[i0, i1] -> [(i1)] }]" 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/schedule/feautrier_compressed.sc: -------------------------------------------------------------------------------- 1 | # Check that the Feautrier schedule is not confused by 2 | # compressed nodes in a subgraph of the original dependence graph. 3 | # OPTIONS: --schedule-algorithm=feautrier 4 | domain: { A[]; B[0]; C[] } 5 | validity: { A[] -> B[0] } 6 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/schedule/feautrier_compressed.st: -------------------------------------------------------------------------------- 1 | domain: "{ B[0]; C[]; A[] }" 2 | child: 3 | set: 4 | - filter: "{ B[i0]; A[] }" 5 | child: 6 | schedule: "[{ B[i0] -> [(1)]; A[] -> [(0)] }]" 7 | - filter: "{ C[] }" 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/seghir-vd.pip: -------------------------------------------------------------------------------- 1 | 0 6 2 | 3 | -1 4 | 5 | 9 8 6 | 0 0 0 1 1 0 0 2 7 | 1 2 1 0 0 1 0 0 8 | 1 0 1 0 -1 0 0 -1 9 | 1 -2 -1 0 0 0 0 -1 10 | 1 7 3 0 0 0 0 -1 11 | 1 -6 -4 0 1 0 3 1 12 | 1 -7 -3 0 0 1 6 4 13 | 1 0 0 0 0 0 1 0 14 | 1 0 0 0 0 0 0 1 15 | 16 | Urs_parms 17 | Urs_unknowns 18 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/set.omega: -------------------------------------------------------------------------------- 1 | {[y]: Exists ( alpha : 2alpha = y)} 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/small.pip: -------------------------------------------------------------------------------- 1 | 0 2 2 | 3 | -1 4 | 5 | 4 4 6 | 1 1 0 0 7 | 1 0 1 0 8 | 1 1 -3 12 9 | 1 -2 1 3 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/split.pwqp: -------------------------------------------------------------------------------- 1 | [n] -> { [x] -> -1 + [(x+5)/7] : -n - 20 <= x <= n } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/square.pip: -------------------------------------------------------------------------------- 1 | 0 3 2 | 3 | -1 4 | 5 | 4 5 6 | 1 1 0 0 0 7 | 1 -1 0 1 0 8 | 1 0 1 0 0 9 | 1 0 -1 1 0 10 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/sven.pip: -------------------------------------------------------------------------------- 1 | 0 3 2 | 3 | -1 4 | 5 | 2 3 6 | 1 1 -4 7 | 1 -1 10 8 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/test3Deg3Var.pwqp: -------------------------------------------------------------------------------- 1 | [p] -> { [n, m] -> (n + n^3) : n >= 1 and m >= n and m <= p } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/tobi.pip: -------------------------------------------------------------------------------- 1 | 2 3 2 | 1 1 -281 3 | 1 -1 14000 4 | 5 | -1 6 | 7 | 6 6 8 | 0 -392 0 8 -1 0 9 | 0 392 8 0 1 0 10 | 1 -1 0 0 0 0 11 | 1 1 0 0 0 35 12 | 1 392 0 0 1 0 13 | 1 -392 0 0 -1 280 14 | 15 | Urs_unknowns 16 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/toplas.pwqp: -------------------------------------------------------------------------------- 1 | [n] -> { [i0, i1] -> (((4 * n - n^2) + (-3/2 + 2 * n) * i0 - 1/2 * i0^2) - i1) : i1 >= -1 + 3n - i0 and i1 >= -1 + 2n - i0 and i0 >= 0 and i1 <= -2 + 4n - i0 and i0 <= -2 + 4n and i0 <= -1 + 3n and i1 >= 0 and i1 <= -1 + n } 2 | -------------------------------------------------------------------------------- /lib/External/isl/test_inputs/unexpanded.pwqp: -------------------------------------------------------------------------------- 1 | { [x, y] -> ((x - x^2) * y + (-x + x^2) * y^2) : x >= 0 and x <= 2 and y >= 0 and y <= 2 } 2 | -------------------------------------------------------------------------------- /lib/External/isl/uset_from_umap.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* Return the union set that was treated as the union map "umap". 4 | */ 5 | static __isl_give isl_union_set *uset_from_umap(__isl_take isl_union_map *umap) 6 | { 7 | return (isl_union_set *) umap; 8 | } 9 | -------------------------------------------------------------------------------- /lib/External/isl/uset_to_umap.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* Treat "uset" as a union map. 4 | * Internally, isl_union_set is defined to isl_union_map, so in practice, 5 | * this function performs a redundant cast. 6 | */ 7 | static __isl_give isl_union_map *uset_to_umap(__isl_take isl_union_set *uset) 8 | { 9 | return (isl_union_map *) uset; 10 | } 11 | -------------------------------------------------------------------------------- /lib/External/isl_srcdir.c.cmake: -------------------------------------------------------------------------------- 1 | static const char *srcdir = "@ISL_SOURCE_DIR@"; 2 | -------------------------------------------------------------------------------- /lib/External/ppcg/GIT_HEAD_ID: -------------------------------------------------------------------------------- 1 | ppcg-0.07 2 | -------------------------------------------------------------------------------- /lib/External/ppcg/cuda_common.h: -------------------------------------------------------------------------------- 1 | #ifndef _CUDA_COMMON_H_ 2 | #define _CUDA_COMMON_H_ 3 | 4 | #include 5 | 6 | struct cuda_info { 7 | FILE *host_c; 8 | FILE *kernel_c; 9 | FILE *kernel_h; 10 | }; 11 | 12 | void cuda_open_files(struct cuda_info *info, const char *input); 13 | void cuda_close_files(struct cuda_info *info); 14 | 15 | #endif 16 | -------------------------------------------------------------------------------- /lib/External/ppcg/gpu_hybrid.h: -------------------------------------------------------------------------------- 1 | #ifndef GPU_HYBRID_H 2 | #define GPU_HYBRID_H 3 | 4 | #include 5 | 6 | #include "gpu.h" 7 | #include "hybrid.h" 8 | 9 | __isl_give isl_schedule_node *gpu_hybrid_tile(struct gpu_gen *gen, 10 | __isl_take isl_schedule_node *node, __isl_take ppcg_ht_bounds *bounds, 11 | int *tile_sizes); 12 | 13 | #endif 14 | -------------------------------------------------------------------------------- /lib/External/ppcg/m4/ax_check_openmp.m4: -------------------------------------------------------------------------------- 1 | # Check if $CC supports openmp. 2 | AC_DEFUN([AX_CHECK_OPENMP], [ 3 | AC_SUBST(HAVE_OPENMP) 4 | HAVE_OPENMP=no 5 | AC_MSG_CHECKING([for OpenMP support by $CC]) 6 | echo | $CC -x c - -fsyntax-only -fopenmp -Werror >/dev/null 2>/dev/null 7 | if test $? -eq 0; then 8 | HAVE_OPENMP=yes 9 | fi 10 | ]) 11 | -------------------------------------------------------------------------------- /lib/External/ppcg/opencl.h: -------------------------------------------------------------------------------- 1 | #ifndef _OPENCL_H 2 | #define _OPENCL_H 3 | 4 | #include 5 | #include "ppcg_options.h" 6 | #include "ppcg.h" 7 | 8 | int generate_opencl(isl_ctx *ctx, struct ppcg_options *options, 9 | const char *input, const char *output); 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /lib/External/ppcg/tests/call2_opencl_functions.cl: -------------------------------------------------------------------------------- 1 | void copy(__global int b[1000], __global int a[1000], int pos) 2 | { 3 | b[pos] = a[pos]; 4 | } 5 | -------------------------------------------------------------------------------- /lib/External/ppcg/tests/call3_opencl_functions.cl: -------------------------------------------------------------------------------- 1 | void copy(__global int b[100], __global int a[100]) 2 | { 3 | for (int i = 0; i < 100; ++i) 4 | b[i] = a[i]; 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/ppcg/tests/call_opencl_functions.cl: -------------------------------------------------------------------------------- 1 | void copy(__global int b[1000], __global int a[1000], int pos) 2 | { 3 | b[pos] = a[pos]; 4 | } 5 | -------------------------------------------------------------------------------- /lib/External/ppcg/tests/iterator.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int i; 6 | int a[101]; 7 | 8 | i = 0; 9 | #pragma scop 10 | for (i = 0; i < 100; ++i) 11 | a[i] = i; 12 | a[i] = i; 13 | #pragma endscop 14 | if (a[100] != 100) 15 | return EXIT_FAILURE; 16 | 17 | return EXIT_SUCCESS; 18 | } 19 | -------------------------------------------------------------------------------- /lib/External/ppcg/tests/not_accessed_opencl_functions.cl: -------------------------------------------------------------------------------- 1 | void copy(__global int b[1000], __global int a[1000], int pos, 2 | __global int c[1000]) 3 | { 4 | b[pos] = a[pos]; 5 | } 6 | -------------------------------------------------------------------------------- /lib/External/ppcg/tests/scalar.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int a; 6 | #pragma scop 7 | a = 1; 8 | #pragma endscop 9 | if (a != 1) 10 | return EXIT_FAILURE; 11 | 12 | return EXIT_SUCCESS; 13 | } 14 | -------------------------------------------------------------------------------- /lib/External/ppcg/version.c: -------------------------------------------------------------------------------- 1 | #include "gitversion.h" 2 | 3 | const char *ppcg_version(void) 4 | { 5 | return GIT_HEAD_ID"\n"; 6 | } 7 | -------------------------------------------------------------------------------- /lib/Support/Mainpage.h: -------------------------------------------------------------------------------- 1 | /*! \mainpage Polly main page 2 | * 3 | * This is the documentation of http://polly.llvm.org 4 | */ 5 | -------------------------------------------------------------------------------- /test/GPGPU/Inputs/libdevice-functions-copied-into-kernel_libdevice.ll: -------------------------------------------------------------------------------- 1 | define float @__nv_expf(float %a) { 2 | ret float %a 3 | } 4 | define float @__nv_cosf(float %a) { 5 | ret float %a 6 | } 7 | define float @__nv_logf(float %a) { 8 | ret float %a 9 | } 10 | -------------------------------------------------------------------------------- /test/README: -------------------------------------------------------------------------------- 1 | place tests here -------------------------------------------------------------------------------- /test/ScopInliner/ignore-declares.ll: -------------------------------------------------------------------------------- 1 | ; RUN: opt %loadPolly -polly-detect-full-functions -polly-scop-inliner \ 2 | ; RUN: -polly-scops -analyze < %s 3 | 4 | ; Check that we do not crash if there are declares. We should skip function 5 | ; declarations and not try to query for domtree. 6 | 7 | declare void @foo() 8 | 9 | -------------------------------------------------------------------------------- /test/UnitIsl/isl_test.sh: -------------------------------------------------------------------------------- 1 | ; RUN: polly-isl-test 2 | -------------------------------------------------------------------------------- /test/UnitIsl/lit.site.cfg.in: -------------------------------------------------------------------------------- 1 | @LIT_SITE_CFG_IN_HEADER@ 2 | 3 | import sys 4 | 5 | config.llvm_tools_dir = "@LLVM_TOOLS_DIR@" 6 | config.polly_obj_root = "@POLLY_BINARY_DIR@" 7 | config.bin_dir = "@CMAKE_RUNTIME_OUTPUT_DIRECTORY@" 8 | 9 | # Let the main config do the real work. 10 | lit_config.load_config(config, "@POLLY_SOURCE_DIR@/test/UnitIsl/lit.cfg") 11 | -------------------------------------------------------------------------------- /test/polly.ll: -------------------------------------------------------------------------------- 1 | ; RUN: opt %loadPolly -polly-scops -S < %s | FileCheck %s 2 | target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" 3 | define void @foo() nounwind { 4 | start: 5 | br label %end 6 | 7 | end: 8 | ret void 9 | } 10 | 11 | ; CHECK: foo 12 | -------------------------------------------------------------------------------- /tools/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if (CUDA_FOUND OR OpenCL_FOUND) 2 | add_subdirectory(GPURuntime) 3 | endif (CUDA_FOUND OR OpenCL_FOUND) 4 | 5 | set(LLVM_COMMON_DEPENDS ${LLVM_COMMON_DEPENDS} PARENT_SCOPE) 6 | -------------------------------------------------------------------------------- /unittests/DeLICM/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_polly_unittest(DeLICMTests 2 | DeLICMTest.cpp 3 | ) 4 | -------------------------------------------------------------------------------- /unittests/Flatten/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_polly_unittest(FlattenTests 2 | FlattenTest.cpp 3 | ) 4 | -------------------------------------------------------------------------------- /unittests/Isl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_polly_unittest(IslTests 2 | IslTest.cpp 3 | ) 4 | -------------------------------------------------------------------------------- /unittests/ScheduleOptimizer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_polly_unittest(ScheduleOptimizerTests 2 | ScheduleOptimizerTest.cpp 3 | ) 4 | -------------------------------------------------------------------------------- /unittests/ScopPassManager/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_polly_unittest(ScopPassManagerTests 2 | PassManagerTest.cpp 3 | ) 4 | -------------------------------------------------------------------------------- /unittests/Support/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_polly_unittest(ISLToolsTests 2 | ISLTools.cpp 3 | ) 4 | -------------------------------------------------------------------------------- /www/.htaccess: -------------------------------------------------------------------------------- 1 | AddHandler server-parsed .html 2 | -------------------------------------------------------------------------------- /www/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/favicon.ico -------------------------------------------------------------------------------- /www/google1242f26b67e33344.html: -------------------------------------------------------------------------------- 1 | google-site-verification: google1242f26b67e33344.html -------------------------------------------------------------------------------- /www/images/GEMM_double.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/GEMM_double.png -------------------------------------------------------------------------------- /www/images/architecture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/architecture.png -------------------------------------------------------------------------------- /www/images/header-background.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/header-background.png -------------------------------------------------------------------------------- /www/images/iit-madras.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/iit-madras.png -------------------------------------------------------------------------------- /www/images/osu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/osu.png -------------------------------------------------------------------------------- /www/images/performance/parallel-large.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/performance/parallel-large.png -------------------------------------------------------------------------------- /www/images/performance/parallel-small.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/performance/parallel-small.png -------------------------------------------------------------------------------- /www/images/performance/sequential-large.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/performance/sequential-large.png -------------------------------------------------------------------------------- /www/images/performance/sequential-small.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/performance/sequential-small.png -------------------------------------------------------------------------------- /www/images/pollylabs.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/pollylabs.png -------------------------------------------------------------------------------- /www/images/sys-uni.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/sys-uni.png -------------------------------------------------------------------------------- /www/images/uni-passau.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/uni-passau.png -------------------------------------------------------------------------------- /www/images/video-summit-2011.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/images/video-summit-2011.png -------------------------------------------------------------------------------- /www/publications/grosser-diploma-thesis.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/publications/grosser-diploma-thesis.pdf -------------------------------------------------------------------------------- /www/publications/grosser-impact-2011-slides.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/publications/grosser-impact-2011-slides.pdf -------------------------------------------------------------------------------- /www/publications/grosser-impact-2011.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/publications/grosser-impact-2011.pdf -------------------------------------------------------------------------------- /www/publications/kernelgen-ncar-2012-slides.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/publications/kernelgen-ncar-2012-slides.pdf -------------------------------------------------------------------------------- /www/publications/kernelgen-pavt-2012-slides.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/publications/kernelgen-pavt-2012-slides.pdf -------------------------------------------------------------------------------- /www/publications/raghesh-a-masters-thesis.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/llvm-mirror/polly/eb0a81fa94e55c40a4a4d7b316e787ccd8129b71/www/publications/raghesh-a-masters-thesis.pdf --------------------------------------------------------------------------------