]> git.pld-linux.org Git - packages/candl.git/blame - candl-git.patch
projects / packages / candl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- apply update to 0.6.3 as patch applied on top of git patch
[packages/candl.git] / candl-git.patch
CommitLineData
65a2ccbc
JB		 1diff --git a/.gitmodules b/.gitmodules
2new file mode 100644
3index 0000000..3279daf
4--- /dev/null
5+++ b/.gitmodules
6@@ -0,0 +1,6 @@
7+[submodule "osl"]
8+ path = osl
9+ url = https://github.com/periscop/openscop.git
10+[submodule "piplib"]
11+ path = piplib
12+ url = https://github.com/periscop/piplib.git
13diff --git a/CMakeLists.txt b/CMakeLists.txt
14new file mode 100755
15index 0000000..a16d5e4
16--- /dev/null
17+++ b/CMakeLists.txt
18@@ -0,0 +1,249 @@
19+cmake_minimum_required(VERSION 2.8)
20+
21+
22+set(PACKAGE_VERSION "0.6.2")
23+set(RELEASE "${PACKAGE_VERSION}")
24+set(BITS "32")
25+set(DEFINE_HAS_ISL_LIB "")
26+set(top_srcdir "${CMAKE_CURRENT_SOURCE_DIR}")
27+
28+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
29+
30+
31+# User's settings - C Flags
32+
33+# set(release "TRUE")
34+ set(release "FALSE")
35+
36+ # Release
37+ if (release)
38+ set(CMAKE_C_FLAGS "-O3")
39+ # Debug # valgrind --show-reachable=yes --leak-check=full -v exe
40+ else()
41+ set(CMAKE_C_FLAGS "-O0 -g3")
42+ endif()
43+
44+# User's settings - General C Flags
45+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -pedantic -std=c99")
46+
47+
48+# Build doxygen
49+ find_package(Doxygen)
50+ if (DOXYGEN_FOUND)
51+ configure_file("doc/Doxyfile.in" "Doxyfile")
52+ add_custom_target(
53+ doxygen
54+ ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
55+ WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
56+ COMMENT "Generating API documentation with Doxygen" VERBATIM
57+ )
58+ else()
59+ message (STATUS "Doxygen not found :( API documentation can not be built")
60+ endif()
61+
62+# Build documentation
63+
64+ # doc
65+ find_program(texi2pdf_exe texi2pdf)
66+ if (texi2pdf_exe)
67+ add_custom_target(
68+ doc
69+ ${texi2pdf_exe} ${CMAKE_CURRENT_SOURCE_DIR}/doc/candl.texi --output=${CMAKE_CURRENT_BINARY_DIR}/candl.pdf
70+ WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
71+ COMMENT "Generating documentation (pdf) (with texi2pdf)" VERBATIM
72+ )
73+ else()
74+ message (STATUS "texi2pdf not found :( Documentation can not be built")
75+ endif()
76+
77+
78+# osl
79+ find_package(osl REQUIRED)
80+
81+# GMP & piplib
82+ message(STATUS "---")
83+ find_library(gmp_LIB gmp)
84+ if (gmp_LIB)
85+ message (STATUS "Library gmp found =) ${gmp_LIB}")
86+ set(BITS "MP")
87+ # piplibMP
88+ find_package(piplibMP REQUIRED)
89+ else()
90+ message(STATUS "Library gmp not found :(")
91+ # piplib64
92+ find_package(piplib64 REQUIRED)
93+ endif()
94+
95+# Include directories (to use #include <> instead of #include "")
96+
97+ # include/candl/macros.h
98+ configure_file("include/candl/macros.h.in" "include/candl/macros.h")
99+ include_directories("${CMAKE_CURRENT_BINARY_DIR}/include")
100+ # candl
101+ include_directories("./include")
102+
103+
104+# Compiler log
105+ message(STATUS "---")
106+ message(STATUS "C compiler = ${CMAKE_C_COMPILER}")
107+ if (release)
108+ message(STATUS "Mode Release")
109+ else()
110+ message(STATUS "Mode Debug")
111+ endif()
112+ message(STATUS "C flags = ${CMAKE_C_FLAGS}")
113+
114+
115+# Library
116+
117+ message(STATUS "---")
118+
119+ # files .c
120+ file(
121+ GLOB_RECURSE
122+ sources
123+ source/*
124+ )
125+ string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/source/candl.c;" "" sources "${sources}") # with ;
126+ string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/source/candl.c" "" sources "${sources}") # without ;
127+
128+ # Shared
129+ add_library(
130+ candl
131+ SHARED
132+ ${sources}
133+ )
134+ target_link_libraries(candl ${OSL_LIBRARY})
135+ if (gmp_LIB)
136+ target_link_libraries(candl ${PIPLIBMP_LIBRARY})
137+ else()
138+ target_link_libraries(candl ${PIPLIB64_LIBRARY})
139+ endif()
140+ get_property(candl_lib_location TARGET candl PROPERTY LOCATION)
141+ message(STATUS "Add candl library (shared) ${candl_lib_location}")
142+
143+ # Static
144+ add_library(
145+ candl_static
146+ STATIC
147+ ${sources}
148+ )
149+ set_target_properties(candl_static PROPERTIES OUTPUT_NAME candl)
150+ if (gmp_LIB)
151+ target_link_libraries(candl_static ${PIPLIBMP_LIBRARY})
152+ else()
153+ target_link_libraries(candl_static ${PIPLIB64_LIBRARY})
154+ endif()
155+ target_link_libraries(candl_static ${OSL_LIBRARY})
156+ get_property(candl_static_lib_location TARGET candl_static PROPERTY LOCATION)
157+ message(STATUS "Add candl library (static) ${candl_static_lib_location}")
158+
159+
160+# Executables & tests
161+
162+ message(STATUS "---") # candl
163+
164+ message(STATUS "Add executable candl")
165+ add_executable(candl_exe "source/candl.c")
166+ set_target_properties(candl_exe PROPERTIES OUTPUT_NAME "candl")
167+ target_link_libraries(candl_exe candl_static ${OSL_LIBRARY})
168+ if (gmp_LIB)
169+ target_link_libraries(candl_exe candl_static ${gmp_LIB})
170+ endif()
171+
172+ # candl test
173+ find_program(bash_exe bash)
174+ if (bash_exe)
175+
176+ message(STATUS "---")
177+
178+ enable_testing()
179+
180+ file(
181+ GLOB_RECURSE
182+ tests_unitary
183+ tests/unitary/*.c
184+ )
185+
186+ foreach(test ${tests_unitary})
187+ message(STATUS "Add Unitary test ${test}")
188+ add_test(
189+ "tests_unitary_${test}"
190+ "${bash_exe}"
191+ "${CMAKE_CURRENT_SOURCE_DIR}/tests/checker.sh"
192+ "${test}"
193+ "${test}"
194+ "0"
195+ )
196+ endforeach()
197+
198+ file(
199+ GLOB_RECURSE
200+ tests_transformations_must_fail
201+ tests/transformations/must_fail/*.c
202+ )
203+
204+ foreach(test ${tests_transformations_must_fail})
205+ message(STATUS "Add Transformation must fail test ${test}")
206+ add_test(
207+ "tests_transformations_must_fail_${test}"
208+ "${bash_exe}"
209+ "${CMAKE_CURRENT_SOURCE_DIR}/tests/checker.sh"
210+ "${test}"
211+ "${test}"
212+ "1"
213+ )
214+ endforeach()
215+
216+ file(
217+ GLOB_RECURSE
218+ tests_transformations_working
219+ tests/transformations/working/*.c
220+ )
221+
222+ foreach(test ${tests_transformations_working})
223+ message(STATUS "Add Transformation working test ${test}")
224+ add_test(
225+ "tests_transformations_working_${test}"
226+ "${bash_exe}"
227+ "${CMAKE_CURRENT_SOURCE_DIR}/tests/checker.sh"
228+ "${test}"
229+ "${test}"
230+ "1"
231+ )
232+ endforeach()
233+
234+ endif()
235+
236+
237+# Install
238+
239+ install(TARGETS candl LIBRARY DESTINATION lib)
240+ install(TARGETS candl_static ARCHIVE DESTINATION lib)
241+ install(DIRECTORY include/ DESTINATION include FILES_MATCHING PATTERN "*.h")
242+ install(DIRECTORY include/ DESTINATION include FILES_MATCHING PATTERN "*.hpp")
243+ install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include/" DESTINATION include FILES_MATCHING PATTERN "*.h")
244+ install(FILES candl-config.cmake DESTINATION lib/candl)
245+ install(TARGETS candl_exe RUNTIME DESTINATION bin)
246+
247+
248+# Little help
249+
250+ message(STATUS "You can execute:")
251+ message(STATUS " make # To compile candl library & candl")
252+ if (bash_exe)
253+ message(STATUS " make test # To execute tests")
254+ message(STATUS " (with the first candl in the $PATH (?))")
255+ endif()
256+ message(STATUS " make install # To install library, include and CMake module")
257+ message(STATUS " # If you need root access:")
258+ message(STATUS " # sudo make install")
259+ message(STATUS " # su -c \"make install\"")
260+ if (DOXYGEN_FOUND)
261+ message(STATUS " make doxygen # To generate the Doxygen")
262+ endif()
263+ if( texi2pdf_exe)
264+ message(STATUS " make doc # To generate the documentation")
265+ endif()
266+
267+ message(STATUS "---")
268diff --git a/Makefile.am b/Makefile.am
269index fefbf45..6839b4b 100644
270--- a/Makefile.am
271+++ b/Makefile.am
272@@ -32,39 +32,90 @@
273 # * *
274 # *****************************************************************************/
275
276+#############################################################################
277+
278+if BUNDLED_OSL
279+ MAYBE_OSL = osl
280+ OSL_LA = $(top_builddir)/osl/libosl.la
281+endif
282+if BUNDLED_PIPLIB
283+ MAYBE_PIPLIB = piplib
284+ PIPLIB_LA = $(top_builddir)/piplib/libpiplib$(BITS).la
285+endif
286+
287+SUBDIRS = $(MAYBE_OSL) $(MAYBE_PIPLIB) doc tests
288+DIST_SUBDIRS = $(MAYBE_OSL) $(MAYBE_PIPLIB) doc tests
289+ACLOCAL_AMFLAGS = -I m4
290+
291+#############################################################################
292+
293+bin_PROGRAMS = candl
294+lib_LTLIBRARIES = libcandl.la
295
296 #############################################################################
297-SUBDIRS = doc source include tests
298
299+pkginclude_HEADERS = \
300+ include/candl/candl.h \
301+ include/candl/dependence.h \
302+ include/candl/scop.h \
303+ include/candl/statement.h \
304+ include/candl/macros.h \
305+ include/candl/util.h \
306+ include/candl/ddv.h \
307+ include/candl/matrix.h \
308+ include/candl/options.h \
309+ include/candl/piplib.h \
310+ include/candl/piplib-wrapper.h \
311+ include/candl/violation.h
312+
313+DEFAULT_INCLUDES = -I.
314+INCLUDES = -I$(top_builddir)/include -I$(top_srcdir)/include
315+AM_CFLAGS = $(CFLAGS_WARN)
316
317 #############################################################################
318-ACLOCAL_AMFLAGS = -I autoconf
319
320-m4datadir = $(datadir)/aclocal
321+EXTRA_DIST = COPYING.LESSER AUTHORS
322+
323+libcandl_la_LIBADD = @OSL_LIBS@ @PIPLIB_LIBS@ $(OSL_LA) $(PIPLIB_LA)
324+libcandl_la_CPPFLAGS = @OSL_CPPFLAGS@ @PIPLIB_CPPFLAGS@ -g
325+libcandl_la_LDFLAGS = @OSL_LDFLAGS@ @PIPLIB_LDFLAGS@
326+libcandl_la_SOURCES = \
327+ source/dependence.c \
328+ source/ddv.c \
329+ source/scop.c \
330+ source/statement.c \
331+ source/util.c \
332+ source/isl-wrapper.c \
333+ source/matrix.c \
334+ source/options.c \
335+ source/piplib-wrapper.c \
336+ source/pruning.c \
337+ source/violation.c
338
339-EXTRA_DIST = COPYING.LESSER AUTHORS
340+#############################################################################
341
342-AUX_DIST = \
343- $(ac_aux_dir)/config.guess \
344- $(ac_aux_dir)/config.sub \
345- $(ac_aux_dir)/install-sh \
346- $(ac_aux_dir)/ltmain.sh \
347- $(ac_aux_dir)/missing \
348- $(ac_aux_dir)/depcomp \
349- $(ac_aux_dir)/texinfo.tex
350+LDADD = @CANDL_LIBS@ @OSL_LIBS@ @PIPLIB_LIBS@
351+candl_CPPFLAGS = @OSL_CPPFLAGS@ @PIPLIB_CPPFLAGS@ -g -Wall
352+candl_LDFLAGS = #@OSL_LDFLAGS@ @PIPLIB_LDFLAGS@ # TO BE REMOVED
353+candl_DEPENDENCIES = libcandl.la
354+candl_SOURCES = source/candl.c
355
356+#############################################################################
357
358-MAINTAINERCLEANFILES = \
359- Makefile.in \
360- aclocal.m4 \
361- configure \
362- source/stamp-h.in \
363+MAINTAINERCLEANFILES = \
364+ Makefile.in \
365+ aclocal.m4 \
366+ configure \
367 $(AUX_DIST)
368
369 #############################################################################
370+
371 dist-hook:
372 (cd $(distdir) && mkdir -p $(ac_aux_dir))
373 for file in $(AUX_DIST); do \
374 cp $$file $(distdir)/$$file; \
375 done
376 #############################################################################
377+
378+valcheck:
379+ $(MAKE) valcheck -C tests
380diff --git a/README b/README
381index 1b20de6..864d102 100644
382--- a/README
383+++ b/README
384@@ -5,7 +5,7 @@
385 Install
386 -------
387
388-To install candl, PIPLib must be installed. Optionally, scoplib must
389+To install candl, PIPLib must be installed. Optionally, OpenScop library must
390 be installed to enable SCoP support.
391
392 $> ./configure --with-piplib=/path/to/piplib/install --with-scoplib=/path/to/scoplib/install
393@@ -15,6 +15,32 @@ $> make
394 $> make install
395
396
397+Alternatively, to use bunled PIPLib and OpenScop library, follow following command
398+sequence:
399+
400+$> ./get_submodules.sh
401+
402+$> ./autogen.sh
403+
404+$> ./configure --with-piplib=bundled --with-scoplib=bundled
405+
406+$> make
407+
408+$> make install
409+
410+Alternative: Install with CMake
411+-------------------------------
412+
413+$> mkdir build
414+$> cd build
415+$> cmake .. # -DCMAKE_INSTALL_PREFIX="/your/install/directory"
416+$> make
417+$> make test
418+$> # make install # sudo make install # su -c "make install"
419+$> make doc
420+$> make doxygen
421+
422+
423 Support
424 -------
425
426diff --git a/TODO b/TODO
427new file mode 100644
428index 0000000..74b6087
429--- /dev/null
430+++ b/TODO
431@@ -0,0 +1,59 @@
432+
433+- unchecked -commute
434+
435+- lastwriter not finished
436+ see the FIXME in the function candl_dep_compute_lastwriter
437+
438+- compilation error with ISL :
439+ To test it, in isl-wrapper change #ifdef CANDL_SUPPORTS_ISL to
440+ #ifndef CANDL_SUPPORTS_ISL
441+
442+ The error is :
443+ source/isl-wrapper.c: In function ‘isl_constraint_read_from_matrix’:
444+ source/isl-wrapper.c:79: warning: passing argument 1 of ‘isl_equality_alloc’ from incompatible pointer type
445+ /home/jpoudroux/usr/include/isl/constraint.h:28: note: expected ‘struct isl_local_space *’ but argument is of type ‘struct isl_space *’
446+ source/isl-wrapper.c:81: warning: passing argument 1 of ‘isl_inequality_alloc’ from incompatible pointer type
447+ /home/jpoudroux/usr/include/isl/constraint.h:29: note: expected ‘struct isl_local_space *’ but argument is of type ‘struct isl_space *’
448+
449+- prunnning not finish (prunning.c: line 258 to 328)
450+ Uncomment the CANDL_COMPILE_PRUNNING in candl.h, or remove the ifdef in
451+ prunning.c
452+
453+- change the type of the dependence/violation domain
454+ (at the end of candl_dependence_build_system and candl_matrix_violation)
455+ today it's : OSL_UNDEFINED
456+
457+- candl_usr_init
458+ the statements must be sorted to compute the statement label
459+ the problem is if the scop is reordered, the second transformed scop
460+ must be "aligned" with it (the first statement need to corresponds to the first
461+ statement of the second scop, but the scattering could be different)
462+
463+ Functions of clay, which could return a non ordered scop :
464+ (they create new statements)
465+ iss, unroll, peel
466+
467+- in pip_has_rational_point:
468+ -> FIXME (dependence.c:2243)
469+
470+- autocorrect not implemented yet
471+
472+- compilation warning with gmp :
473+ /usr/bin/ld: warning: libgmp.so.3, needed by /home/jpoudroux/usr/lib/libosl.so, may conflict with libgmp.so.10
474+
475+- autoreconf error in the piplib module
476+ -> piplib must be installed in /
477+
478+ or execute these commands :
479+ $ cd piplib
480+ $ echo "AM_PROG_CC_C_O" >>configure.in
481+ $ touch NEWS AUTHORS ChangeLog
482+ $ cd ..
483+ $ ./redo.sh
484+
485+ If you want to set piplib as "bundled", uncomment these lines in the
486+ configure.ac :
487+ 295: if test $with_piplib = bundled; then
488+ 296: AC_CONFIG_SUBDIRS(piplib)
489+ 297: fi
490+
491diff --git a/autoconf/.gitignore b/autoconf/.gitignore
492new file mode 100644
493index 0000000..e69de29
494diff --git a/autoconf/candl.m4 b/autoconf/candl.m4
495deleted file mode 100644
496index 2d1347e..0000000
497--- a/autoconf/candl.m4
498+++ /dev/null
499@@ -1,81 +0,0 @@
500-AC_DEFUN([CANDL_ARG_LIBS_DEPENDENCIES],
501-[
502-dnl Add $prefix to the library path (convenience).
503- if test -e ${prefix}/include; then
504- CPPFLAGS="${CPPFLAGS} -I${prefix}/include"
505- fi;
506- if test -e ${prefix}/lib; then
507- LDFLAGS="${LDFLAGS} -L${prefix}/lib"
508- fi;
509-dnl Offer --with-piplib.
510- AC_ARG_WITH(piplib,
511- AC_HELP_STRING([--with-piplib=DIR],
512- [DIR Location of PIPLib package]),
513- [with_piplib=$withval;
514- CPPFLAGS="${CPPFLAGS} -I$withval/include";
515- LDFLAGS="${LDFLAGS} -L$withval/lib"
516- ],
517- [with_piplib=yes])
518-dnl Check for piplib existence.
519- AS_IF([test "x$with_piplib" != xno],
520- [AC_SEARCH_LIBS([pip_solve], [piplib$BITS],
521- [LIBS="-lpiplib$BITS $LIBS";
522- AC_DEFINE([HAVE_LIBPIPLIB], [1], [Define if you have libpiplib$BITS])
523- ],
524- [if test "x$with_piplib" != xcheck; then
525- AC_MSG_FAILURE([--with-piplib was given, but test for piplib failed])
526- fi
527- ])
528- ])
529-dnl Offer --with-scoplib.
530- AC_ARG_WITH(scoplib,
531- AC_HELP_STRING([--with-scoplib=DIR],
532- [DIR Location of ScopLib package]),
533- [with_scoplib=$withval;
534- CPPFLAGS="${CPPFLAGS} -I$withval/include";
535- LDFLAGS="${LDFLAGS} -L$withval/lib"
536- ],
537- [with_scoplib=check])
538-dnl Check for scoplib existence.
539- AS_IF([test "x$with_scoplib" != xno],
540- [AC_SEARCH_LIBS([scoplib_scop_read], [scoplib],
541- [LIBS="-lscoplib $LIBS";
542- DEFINE_HAS_SCOPLIB_LIB="# define CANDL_SUPPORTS_SCOPLIB"
543- ],
544- [DEFINE_HAS_SCOPLIB_LIB=""
545- if test "x$with_scoplib" != xcheck; then
546- AC_MSG_FAILURE([Test for ScopLib failed. Use --with-scoplib to specify libscoplib path.])
547- fi
548- ])
549- ])
550-dnl Offer --with-gmp-prefix.
551- AC_ARG_WITH(gmp-prefix,
552- AC_HELP_STRING([--with-gmp-prefix=DIR],
553- [DIR Location of GMP package (only headers are needed)]),
554- [CPPFLAGS="${CPPFLAGS} -I$withval/include";
555- LDFLAGS="${LDFLAGS} -L$withval/lib";
556- ])
557-dnl Offer --with-isl.
558- AC_ARG_WITH(isl,
559- AC_HELP_STRING([--with-isl=DIR],
560- [DIR Location of Isl package]),
561- [with_isl=$withval;
562- CPPFLAGS="${CPPFLAGS} -I$withval/include";
563- LDFLAGS="${LDFLAGS} -L$withval/lib"
564- ],
565- [with_isl=check])
566-dnl Check for isl existence.
567- AS_IF([test "x$with_isl" != xno],
568- [AC_SEARCH_LIBS([isl_version], [isl],
569- [LIBS="-lisl $LIBS";
570- DEFINE_HAS_ISL_LIB="# define CANDL_SUPPORTS_ISL"
571- ],
572- [DEFINE_HAS_ISL_LIB=""
573- if test "x$with_isl" != xcheck; then
574- AC_MSG_FAILURE([Test for Isl failed. Use --with-isl to specify libisl path.])
575- fi
576- ])
577- ])
578-])
579-
580-
581#diff --git a/autogen.sh b/autogen.sh
582#index b67de1f..c27fa40 100755
583#--- a/autogen.sh
584#+++ b/autogen.sh
585#@@ -1,5 +1,8 @@
586#-#! /bin/sh
587#-
588#-aclocal -I autoconf
589#-libtoolize --force --copy
590#-autoreconf -vfi
591#+#!/bin/sh
592#+autoreconf -i
593#+if test -f osl/autogen.sh; then
594#+ (cd osl; ./autogen.sh)
595#+fi
596#+if test -f piplib/autogen.sh; then
597#+ (cd piplib; ./autogen.sh)
598#+fi
599diff --git a/candl-config.cmake b/candl-config.cmake
600new file mode 100644
601index 0000000..c1047d0
602--- /dev/null
603+++ b/candl-config.cmake
604@@ -0,0 +1,25 @@
605+# Try to find the candl library
606+
607+# CANDL_FOUND - System has candl lib
608+# CANDL_INCLUDE_DIR - The candl include directory
609+# CANDL_LIBRARY - Library needed to use candl
610+
611+
612+if (CANDL_INCLUDE_DIR AND CANDL_LIBRARY)
613+ # Already in cache, be silent
614+ set(CANDL_FIND_QUIETLY TRUE)
615+endif()
616+
617+find_path(CANDL_INCLUDE_DIR NAMES candl/candl.h)
618+find_library(CANDL_LIBRARY NAMES candl)
619+
620+if (CANDL_LIBRARY AND CANDL_INCLUDE_DIR)
621+ message(STATUS "Library candl found =) ${CANDL_LIBRARY}")
622+else()
623+ message(STATUS "Library candl not found =(")
624+endif()
625+
626+include(FindPackageHandleStandardArgs)
627+FIND_PACKAGE_HANDLE_STANDARD_ARGS(CANDL DEFAULT_MSG CANDL_INCLUDE_DIR CANDL_LIBRARY)
628+
629+mark_as_advanced(CANDL_INCLUDE_DIR CANDL_LIBRARY)
630diff --git a/configure.ac b/configure.ac
631new file mode 100644
632index 0000000..03c9ce4
633--- /dev/null
634+++ b/configure.ac
635@@ -0,0 +1,320 @@
636+dnl /**-------------------------------------------------------------------**
637+dnl ** CAnDL **
638+dnl **-------------------------------------------------------------------**
639+dnl ** configure.in **
640+dnl **-------------------------------------------------------------------**
641+dnl ** First version: september 8th 2003 **
642+dnl **-------------------------------------------------------------------**/
643+dnl
644+dnl /**************************************************************************
645+dnl * CAnDL : the Chunky Analyser for Dependences in Loops (experimental) *
646+dnl ***************************************************************************
647+dnl * *
648+dnl * Copyright (C) 2003-2008 Cedric Bastoul *
649+dnl * *
650+dnl * This is free software; you can redistribute it and/or modify it under *
651+dnl * the terms of the GNU General Public License as published by the Free *
652+dnl * Software Foundation; either version 2 of the License, or (at your *
653+dnl * option) any later version. *
654+dnl * *
655+dnl * This software is distributed in the hope that it will be useful, but *
656+dnl * WITHOUT ANY WARRANTY; without even the implied warranty of *
657+dnl * MERCHANTABILITYor FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
658+dnl * General Public License for more details. *
659+dnl * *
660+dnl * You should have received a copy of the GNU General Public License along *
661+dnl * with software; if not, write to the Free Software Foundation, Inc., *
662+dnl * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
663+dnl * *
664+dnl * CAnDL, the Chunky Dependence Analyser *
665+dnl * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
666+dnl * *
667+dnl ***************************************************************************/
668+
669+m4_define([version_major], [0])
670+m4_define([version_minor], [0])
671+m4_define([version_revision], [1])
672+
673+AC_PREREQ(2.53)
674+
675+dnl Fill here the @bug email adress.
676+AC_INIT([candl], [0.6.2], [cedric.bastoul@inria.fr,pouchet@cse.ohio-state.edu])
677+
678+AC_CONFIG_SRCDIR([include/candl/candl.h])
679+
680+dnl Put as most as possible configuration files to an auxialiry
681+dnl directory.
682+AC_CONFIG_AUX_DIR(autoconf)
683+AC_CONFIG_MACRO_DIR([m4])
684+
685+dnl Initialize automake. Here, a special tar version that enables
686+dnl (very) long filenames.
687+#AM_INIT_AUTOMAKE([1.9 tar-ustar no-define foreign dist-bzip2])
688+AM_INIT_AUTOMAKE([foreign])
689+m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
690+
691+dnl default version
692+BITS="MP"
693+CPPFLAGS=-DCANDL_LINEAR_VALUE_IS_MP
694+
695+
696+dnl /**************************************************************************
697+dnl * Checking *
698+dnl **************************************************************************/
699+
700+
701+dnl Checks for programs.
702+AC_PROG_CC
703+AC_PROG_LN_S
704+AC_PROG_MAKE_SET
705+AC_CHECK_PROG(CD, cd)
706+AC_PROG_INSTALL
707+AC_PROG_LIBTOOL
708+AC_CHECK_PROGS(DOXYGEN,doxygen,doxygen)
709+
710+AX_CC_MAXOPT
711+AC_SUBST(CFLAGS_WARN)
712+AX_CFLAGS_WARN_ALL(CFLAGS_WARN)
713+
714+dnl Checks for typedefs, structures, and compiler characteristics.
715+AC_C_CONST
716+AC_TYPE_SIZE_T
717+
718+dnl Checks for header files.
719+AC_HEADER_STDC
720+AC_CHECK_HEADERS([errno.h stddef.h stdlib.h string.h strings.h unistd.h])
721+
722+dnl Checks for library functions.
723+AC_CHECK_FUNCS(strtol)
724+
725+
726+dnl /**************************************************************************
727+dnl * Option setting *
728+dnl **************************************************************************/
729+
730+dnl /**************************************************************************
731+dnl * Where is the OpenScop Library? *
732+dnl **************************************************************************/
733+
734+AX_SUBMODULE(osl,system|build|bundled,system)
735+
736+AC_SUBST(OSL_CPPFLAGS)
737+AC_SUBST(OSL_LDFLAGS)
738+AC_SUBST(OSL_LIBS)
739+case "$with_osl" in
740+bundled)
741+ OSL_CPPFLAGS="-I$srcdir/osl/include -Iosl/include"
742+ OSL_LIBS="$srcdir/osl/libosl.la"
743+ ;;
744+build)
745+ OSL_CPPFLAGS="-I$osl_srcdir/include -I$with_osl_builddir/include"
746+ OSL_LIBS="$with_osl_builddir/libosl.la"
747+ ;;
748+system)
749+ if test "x$with_osl_prefix" != "x"; then
750+ OSL_CPPFLAGS="-I$with_osl_prefix/include"
751+ fi
752+ if test "x$with_osl_exec_prefix" != "x"; then
753+ OSL_LDFLAGS="-L$with_osl_exec_prefix/lib"
754+ fi
755+ OSL_LIBS="$with_osl_prefix/lib/libosl.la -losl"
756+esac
757+AM_CONDITIONAL(BUNDLED_OSL, test $with_osl = bundled)
758+
759+
760+
761+dnl GMP
762+
763+dnl Some default values cause I'm not sure whether autoconf set them, while
764+dnl documentation says it does...
765+gmp_package="yes"
766+gmp_include_package="yes"
767+gmp_library_package="yes"
768+
769+NEED_MP="no"
770+
771+dnl --with-gmp=gmp-path
772+AC_ARG_WITH(gmp,
773+ [ --with-gmp=DIR DIR where the gmp package is installed],
774+ [ echo "Package gmp : $withval" &&
775+ gmp_package=$withval &&
776+ GMP_INC=$gmp_package/include &&
777+ GMP_LIB=$gmp_package/lib &&
778+ CPPFLAGS=-DCANDL_LINEAR_VALUE_IS_MP &&
779+ NEED_MP="yes"])
780+
781+AC_ARG_WITH(gmp-include,
782+ [ --with-gmp-include=DIR DIR where gmp.h is installed],
783+ [ echo "Package gmp-include : $withval" &&
784+ gmp_include_package=$withval &&
785+ GMP_INC=$gmp_include_package &&
786+ CPPFLAGS=-DCANDL_LINEAR_VALUE_IS_MP &&
787+ NEED_MP="yes"])
788+
789+AC_ARG_WITH(gmp-library,
790+ [ --with-gmp-library=DIR DIR where the gmp library is installed],
791+ [ echo "Package gmp-library : $withval" &&
792+ gmp_library_package=$withval &&
793+ GMP_LIB=$gmp_library_package &&
794+ CPPFLAGS=-DCANDL_LINEAR_VALUE_IS_MP &&
795+ NEED_MP="yes"])
796+
797+AC_ARG_ENABLE(int-version,
798+ [ --enable-int-version 'int' (32 bits) version is built],
799+ [ echo "Package int : $enableval" &&
800+ BITS="32" &&
801+ CPPFLAGS=-DCANDL_LINEAR_VALUE_IS_LONG])
802+
803+AC_ARG_ENABLE(llint-version,
804+ [ --enable-llint-version 'long long int' (64 bits) version is built],
805+ [ echo "Package long long int : $enableval" &&
806+ BITS="64" &&
807+ CPPFLAGS=-DCANDL_LINEAR_VALUE_IS_LONGLONG])
808+
809+AC_ARG_ENABLE(mp-version,
810+ [ --enable-mp-version 'MP' (multiple precision) version is built],
811+ [ echo "Package mp : $enableval" &&
812+ BITS="MP" &&
813+ CPPFLAGS=-DCANDL_LINEAR_VALUE_IS_MP &&
814+ NEED_MP="yes"])
815+
816+AC_ARG_ENABLE(piplib-hybrid,
817+ [ --enable-piplib-hybrid Link with piplib-hybrid],
818+ [ echo "Piplib-hybrid support : $enableval" &&
819+ if test "x$enableval" = "xyes"; then
820+ CPPFLAGS=-DCANDL_HAS_PIPLIB_HYBRID
821+ fi])
822+
823+
824+dnl /**************************************************************************
825+dnl * Where is the PipLib Library? *
826+dnl **************************************************************************/
827+
828+AX_SUBMODULE(piplib,system|build|bundled,system)
829+
830+AC_SUBST(PIPLIB_CPPFLAGS)
831+AC_SUBST(PIPLIB_LDFLAGS)
832+AC_SUBST(PIPLIB_LIBS)
833+case "$with_piplib" in
834+bundled)
835+ PIPLIB_CPPFLAGS="-I$srcdir/piplib/include -Ipiplib/include"
836+ PIPLIB_LIBS="$srcdir/piplib/libpiplib$BITS.la"
837+ ;;
838+build)
839+ PIPLIB_CPPFLAGS="-I$piplib_srcdir/include -I$with_piplib_builddir/include"
840+ PIPLIB_LIBS="$with_piplib_builddir/libpiplib$BITS.la"
841+ ;;
842+system)
843+ if test "x$with_piplib_prefix" != "x"; then
844+ PIPLIB_CPPFLAGS="-I$with_piplib_prefix/include"
845+ fi
846+ if test "x$with_piplib_exec_prefix" != "x"; then
847+ PIPLIB_LDFLAGS="-L$with_piplib_exec_prefix/lib"
848+ fi
849+ PIPLIB_LIBS="$with_piplib_prefix/lib/libpiplib$BITS.la -lpiplib$BITS"
850+esac
851+AM_CONDITIONAL(BUNDLED_PIPLIB, test $with_piplib = bundled)
852+
853+
854+
855+dnl /**************************************************************************
856+dnl * Where is GMP? *
857+dnl **************************************************************************/
858+
859+
860+dnl Checking for gmp
861+AC_MSG_CHECKING(whether gmp works)
862+if test "$gmp_package" = "no"; then
863+ echo "GMP package not defined"
864+ AC_MSG_RESULT(no)
865+ TO_BUILD_MP=""
866+else
867+ if test "$NEED_MP" = "no"; then
868+ echo "Mode normal GMP"
869+ TO_BUILD="$TO_BUILD MP"
870+ AC_CHECK_HEADER(gmp.h,
871+ [AC_SEARCH_LIBS([__gmpz_init], [gmp],
872+ [LIBS="$LIBS -lgmp"],
873+ [echo "Can't find gmp library." &&
874+ echo "MP version will not be built." &&
875+ TO_BUILD_MP=""])],
876+ [echo "Can't find gmp headers." &&
877+ echo "MP version will not be built." &&
878+ TO_BUILD_MP=""])
879+ else
880+ dnl Default given by --with-X is "yes", --without-X is "no". We also
881+ dnl initialized manually all gmp_package* variables to "yes" (thus they are
882+ dnl supposed to be "yes" except if the user set them himself).
883+ if test "$gmp_package" != "yes" ; then
884+ echo "(GMP path has been set by user)"
885+ GMP_DIR=$gmp_package
886+ dnl Useful for AC_CHECK_X to find what we want.
887+ CPPFLAGS="-I$GMP_DIR/include $CPPFLAGS"
888+ LDFLAGS="-L$GMP_DIR/lib $LDFLAGS"
889+ fi
890+
891+ if test "$gmp_include_package" != "yes" ; then
892+ CPPFLAGS="-I$GMP_INC $CPPFLAGS"
893+ fi
894+
895+ if test "$gmp_library_package" != "yes" ; then
896+ LDFLAGS="-L$GMP_LIB $LDFLAGS"
897+ fi
898+
899+ AC_CHECK_HEADER(gmp.h,
900+ [],
901+ [AC_MSG_ERROR(Can't find gmp headers.)])
902+ AC_SEARCH_LIBS([__gmpz_init], [gmp],
903+ [LIBS="$LIBS -lgmp"],
904+ [AC_MSG_ERROR(Can't find gmp library.)])
905+
906+ AC_MSG_RESULT(yes)
907+ fi
908+fi
909+
910+dnl /**************************************************************************
911+dnl * Substitutions *
912+dnl **************************************************************************/
913+
914+
915+dnl Substitutions to do.
916+AC_SUBST(BITS)
917+AC_SUBST(DEFINE_HAS_ISL_LIB)
918+AC_SUBST(ac_aux_dir)
919+AC_SUBST(abs_top_srcdir)
920+
921+
922+dnl Configure Makefiles.
923+AC_CONFIG_FILES([
924+ Makefile
925+ doc/Makefile
926+ doc/Doxyfile
927+ include/candl/macros.h
928+ include/candl/piplib.h
929+ tests/Makefile
930+ ],
931+ [test -z "$CONFIG_HEADERS" || echo timestamp > source/stamp-h.in])
932+
933+#if test $with_piplib = system; then
934+# AC_CONFIG_SUBDIRS(piplib)
935+#fi
936+if test $with_osl = bundled; then
937+ AC_CONFIG_SUBDIRS(osl)
938+fi
939+
940+dnl forcing candl to use local libcandl.la
941+dnl if --prefix is not specified
942+CANDL_LIBS="$srcdir/libcandl.la -lcandl"
943+AC_SUBST(CANDL_LIBS)
944+
945+
946+
947+AC_OUTPUT
948+
949+echo " /*-----------------------------------------------*"
950+echo " * Candl configuration is OK *"
951+echo " *-----------------------------------------------*/"
952+echo "It appears that your system is OK to start Candl compilation. You need"
953+echo "now to type \"make\". Lastly type \"make install\" to install Candl on"
954+echo "your system (log as root if necessary)."
955+
956diff --git a/configure.in b/configure.in
957deleted file mode 100644
958index f6cf7ad..0000000
959--- a/configure.in
960+++ /dev/null
961@@ -1,233 +0,0 @@
962-dnl /**-------------------------------------------------------------------**
963-dnl ** CAnDL **
964-dnl **-------------------------------------------------------------------**
965-dnl ** configure.in **
966-dnl **-------------------------------------------------------------------**
967-dnl ** First version: september 8th 2003 **
968-dnl **-------------------------------------------------------------------**/
969-dnl
970-dnl /**************************************************************************
971-dnl * CAnDL : the Chunky Analyser for Dependences in Loops (experimental) *
972-dnl ***************************************************************************
973-dnl * *
974-dnl * Copyright (C) 2003-2008 Cedric Bastoul *
975-dnl * *
976-dnl * This is free software; you can redistribute it and/or modify it under *
977-dnl * the terms of the GNU General Public License as published by the Free *
978-dnl * Software Foundation; either version 2 of the License, or (at your *
979-dnl * option) any later version. *
980-dnl * *
981-dnl * This software is distributed in the hope that it will be useful, but *
982-dnl * WITHOUT ANY WARRANTY; without even the implied warranty of *
983-dnl * MERCHANTABILITYor FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
984-dnl * General Public License for more details. *
985-dnl * *
986-dnl * You should have received a copy of the GNU General Public License along *
987-dnl * with software; if not, write to the Free Software Foundation, Inc., *
988-dnl * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
989-dnl * *
990-dnl * CAnDL, the Chunky Dependence Analyser *
991-dnl * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
992-dnl * *
993-dnl ***************************************************************************/
994-
995-
996-AC_PREREQ(2.13)
997-dnl Fill here the @bug email adress.
998-AC_INIT([candl], [0.6.2], [cedric.bastoul@inria.fr,pouchet@cse.ohio-state.edu])
999-dnl A common file, which serve as a test.
1000-AC_CONFIG_SRCDIR([include/candl/program.h])
1001-dnl Put as most as possible configuration files to an auxialiry
1002-dnl directory.
1003-AC_CONFIG_AUX_DIR([autoconf])
1004-dnl Initialize automake. Here, a special tar version that enables
1005-dnl (very) long filenames.
1006-AM_INIT_AUTOMAKE([1.9 tar-ustar no-define foreign dist-bzip2])
1007-
1008-
1009-dnl default version
1010-BITS="64"
1011-CPPFLAGS=-DLINEAR_VALUE_IS_LONGLONG
1012-
1013-
1014-dnl /**************************************************************************
1015-dnl * Checking *
1016-dnl **************************************************************************/
1017-
1018-
1019-dnl Checks for programs.
1020-AC_PROG_CC
1021-AC_PROG_LN_S
1022-AC_PROG_MAKE_SET
1023-AC_CHECK_PROG(CD, cd)
1024-AC_PROG_LIBTOOL
1025-AC_CHECK_PROGS(DOXYGEN,doxygen,doxygen)
1026-
1027-dnl Checks for typedefs, structures, and compiler characteristics.
1028-AC_C_CONST
1029-AC_TYPE_SIZE_T
1030-
1031-dnl Checks for header files.
1032-AC_HEADER_STDC
1033-AC_CHECK_HEADERS([errno.h stddef.h stdlib.h string.h strings.h unistd.h])
1034-
1035-dnl Checks for library functions.
1036-AC_CHECK_FUNCS(strtol)
1037-
1038-
1039-dnl /**************************************************************************
1040-dnl * Option setting *
1041-dnl **************************************************************************/
1042-
1043-dnl Some default values cause I'm not sure whether autoconf set them, while
1044-dnl documentation says it does...
1045-gmp_package="yes"
1046-gmp_include_package="yes"
1047-gmp_library_package="yes"
1048-
1049-NEED_MP="no"
1050-
1051-dnl --with-gmp=gmp-path
1052-AC_ARG_WITH(gmp,
1053- [ --with-gmp=DIR DIR where the gmp package is installed],
1054- [ echo "Package gmp : $withval" &&
1055- gmp_package=$withval &&
1056- GMP_INC=$gmp_package/include &&
1057- GMP_LIB=$gmp_package/lib &&
1058- CPPFLAGS=-DLINEAR_VALUE_IS_MP &&
1059- NEED_MP="yes"])
1060-
1061-AC_ARG_WITH(gmp-include,
1062- [ --with-gmp-include=DIR DIR where gmp.h is installed],
1063- [ echo "Package gmp-include : $withval" &&
1064- gmp_include_package=$withval &&
1065- GMP_INC=$gmp_include_package &&
1066- CPPFLAGS=-DLINEAR_VALUE_IS_MP &&
1067- NEED_MP="yes"])
1068-
1069-AC_ARG_WITH(gmp-library,
1070- [ --with-gmp-library=DIR DIR where the gmp library is installed],
1071- [ echo "Package gmp-library : $withval" &&
1072- gmp_library_package=$withval &&
1073- GMP_LIB=$gmp_library_package &&
1074- CPPFLAGS=-DLINEAR_VALUE_IS_MP &&
1075- NEED_MP="yes"])
1076-
1077-AC_ARG_ENABLE(int-version,
1078- [ --enable-int-version 'int' (32 bits) version is built],
1079- [ echo "Package int : $enableval" &&
1080- BITS="32" &&
1081- CPPFLAGS=-DLINEAR_VALUE_IS_LONG])
1082-
1083-AC_ARG_ENABLE(llint-version,
1084- [ --enable-llint-version 'long long int' (64 bits) version is built],
1085- [ echo "Package long long int : $enableval" &&
1086- BITS="64" &&
1087- CPPFLAGS=-DLINEAR_VALUE_IS_LONGLONG])
1088-
1089-AC_ARG_ENABLE(mp-version,
1090- [ --enable-mp-version 'MP' (multiple precision) version is built],
1091- [ echo "Package mp : $enableval" &&
1092- BITS="MP" &&
1093- CPPFLAGS=-DLINEAR_VALUE_IS_MP &&
1094- NEED_MP="yes"])
1095-
1096-AC_ARG_ENABLE(piplib-hybrid,
1097- [ --enable-piplib-hybrid Link with piplib-hybrid],
1098- [ echo "Piplib-hybrid support : $enableval" &&
1099- if test "x$enableval" = "xyes"; then
1100- CPPFLAGS=-DCANDL_HAS_PIPLIB_HYBRID
1101- fi])
1102-
1103-
1104-dnl /**************************************************************************
1105-dnl * Where is GMP? *
1106-dnl **************************************************************************/
1107-
1108-
1109-dnl Checking for gmp
1110-AC_MSG_CHECKING(whether gmp works)
1111-if test "$gmp_package" = "no"; then
1112- echo "GMP package not defined"
1113- AC_MSG_RESULT(no)
1114- TO_BUILD_MP=""
1115-else
1116- if test "$NEED_MP" = "no"; then
1117- echo "Mode normal GMP"
1118- TO_BUILD="$TO_BUILD MP"
1119- AC_CHECK_HEADER(gmp.h,
1120- [AC_SEARCH_LIBS([__gmpz_init], [gmp],
1121- [LIBS="$LIBS -lgmp"],
1122- [echo "Can't find gmp library." &&
1123- echo "MP version will not be built." &&
1124- TO_BUILD_MP=""])],
1125- [echo "Can't find gmp headers." &&
1126- echo "MP version will not be built." &&
1127- TO_BUILD_MP=""])
1128- else
1129- dnl Default given by --with-X is "yes", --without-X is "no". We also
1130- dnl initialized manually all gmp_package* variables to "yes" (thus they are
1131- dnl supposed to be "yes" except if the user set them himself).
1132-
1133- if test "$gmp_package" != "yes" ; then
1134- echo "(GMP path has been set by user)"
1135- GMP_DIR=$gmp_package
1136- dnl Useful for AC_CHECK_X to find what we want.
1137- CPPFLAGS="-I$GMP_DIR/include $CPPFLAGS"
1138- LDFLAGS="-L$GMP_DIR/lib $LDFLAGS"
1139- fi
1140-
1141- if test "$gmp_include_package" != "yes" ; then
1142- CPPFLAGS="-I$GMP_INC $CPPFLAGS"
1143- fi
1144-
1145- if test "$gmp_library_package" != "yes" ; then
1146- LDFLAGS="-L$GMP_LIB $LDFLAGS"
1147- fi
1148-
1149- AC_CHECK_HEADER(gmp.h,
1150- [],
1151- [AC_MSG_ERROR(Can't find gmp headers.)])
1152- AC_SEARCH_LIBS([__gmpz_init], [gmp],
1153- [LIBS="$LIBS -lgmp"],
1154- [AC_MSG_ERROR(Can't find gmp library.)])
1155-
1156- AC_MSG_RESULT(yes)
1157- fi
1158-fi
1159-
1160-CANDL_ARG_LIBS_DEPENDENCIES
1161-
1162-
1163-
1164-dnl /**************************************************************************
1165-dnl * Substitutions *
1166-dnl **************************************************************************/
1167-
1168-
1169-dnl Substitutions to do.
1170-AC_SUBST(BITS)
1171-AC_SUBST(DEFINE_HAS_SCOPLIB_LIB)
1172-AC_SUBST(DEFINE_HAS_ISL_LIB)
1173-AC_SUBST(ac_aux_dir)
1174-
1175-dnl Configure Makefiles.
1176-AC_CONFIG_FILES([
1177- Makefile
1178- doc/Makefile
1179- doc/Doxyfile
1180- include/Makefile
1181- include/candl/candl.h
1182- source/Makefile
1183- tests/Makefile
1184- ],
1185- [test -z "$CONFIG_HEADERS" || echo timestamp > source/stamp-h.in])
1186-
1187-AC_OUTPUT
1188-
1189-echo " /*-----------------------------------------------*"
1190-echo " * Candl configuration is OK *"
1191-echo " *-----------------------------------------------*/"
1192-echo "It appears that your system is OK to start Candl compilation. You need"
1193-echo "now to type \"make\". Lastly type \"make install\" to install Candl on"
1194-echo "your system (log as root if necessary)."
1195diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
1196index e172bda..510d8f1 100644
1197--- a/doc/Doxyfile.in
1198+++ b/doc/Doxyfile.in
1199@@ -478,7 +478,8 @@ WARN_LOGFILE =
1200 # with spaces.
1201
1202 INPUT = @top_srcdir@/source \
1203- @top_srcdir@/include/candl
1204+ @top_srcdir@/include/candl \
1205+ include/candl/macros.h
1206
1207 # This tag can be used to specify the character encoding of the source files that
1208 # doxygen parses. Internally doxygen uses the UTF-8 encoding, which is also the default
1209diff --git a/get_submodules.sh b/get_submodules.sh
1210new file mode 100755
1211index 0000000..94842b6
1212--- /dev/null
1213+++ b/get_submodules.sh
1214@@ -0,0 +1,9 @@
1215+#!/bin/bash
1216+git submodule init
1217+git submodule update
1218+if test -f osl/autogen.sh; then
1219+ (cd osl; ./autogen.sh && ./configure)
1220+fi
1221+if test -f piplib/autogen.sh; then
1222+ (cd piplib; ./autogen.sh && ./configure)
1223+fi
1224diff --git a/include/Makefile.am b/include/Makefile.am
1225deleted file mode 100644
1226index ed48dcd..0000000
1227--- a/include/Makefile.am
1228+++ /dev/null
1229@@ -1,54 +0,0 @@
1230-#
1231-# /**-------------------------------------------------------------------**
1232-# ** CAnDL **
1233-# **-------------------------------------------------------------------**
1234-# ** Makefile.am **
1235-# **-------------------------------------------------------------------**
1236-# ** First version: september 8th 2003 **
1237-# **-------------------------------------------------------------------**/
1238-#
1239-#/*****************************************************************************
1240-# * CAnDL : the Chunky Analyser for Dependences in Loops (experimental) *
1241-# *****************************************************************************
1242-# * *
1243-# * Copyright (C) 2003-2008 Cedric Bastoul *
1244-# * *
1245-# * This is free software; you can redistribute it and/or modify it under the *
1246-# * terms of the GNU General Public License as published by the Free Software *
1247-# * Foundation; either version 2 of the License, or (at your option) any *
1248-# * later version. *
1249-# * *
1250-# * This software is distributed in the hope that it will be useful, but *
1251-# * WITHOUT ANY WARRANTY; without even the implied warranty of *
1252-# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General *
1253-# * Public License for more details. *
1254-# * *
1255-# * You should have received a copy of the GNU General Public License along *
1256-# * with software; if not, write to the Free Software Foundation, Inc., *
1257-# * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
1258-# * *
1259-# * CAnDL, the Chunky Dependence Analyser *
1260-# * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
1261-# * *
1262-# *****************************************************************************/
1263-
1264-
1265-#############################################################################
1266-SUBDIRS =
1267-
1268-#############################################################################
1269-MAINTAINERCLEANFILES = Makefile.in
1270-
1271-#############################################################################
1272-
1273-pkginclude_HEADERS = \
1274- candl/candl.h \
1275- candl/dependence.h \
1276- candl/ddv.h \
1277- candl/matrix.h \
1278- candl/options.h \
1279- candl/piplib-wrapper.h \
1280- candl/program.h \
1281- candl/pruning.h \
1282- candl/statement.h \
1283- candl/violation.h
1284diff --git a/include/candl/candl.h b/include/candl/candl.h
1285new file mode 100644
1286index 0000000..926511f
1287--- /dev/null
1288+++ b/include/candl/candl.h
1289@@ -0,0 +1,50 @@
1290+
1291+ /**------ ( ----------------------------------------------------------**
1292+ ** )\ CAnDL **
1293+ **----- / ) --------------------------------------------------------**
1294+ ** ( * ( candl.h **
1295+ **---- \#/ --------------------------------------------------------**
1296+ ** .-"#'-. First version: september 8th 2003 **
1297+ **--- |"-.-"| -------------------------------------------------------**
1298+ | |
1299+ | |
1300+ ******** | | *************************************************************
1301+ * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
1302+ ******************************************************************************
1303+ * *
1304+ * Copyright (C) 2003-2008 Cedric Bastoul *
1305+ * *
1306+ * This is free software; you can redistribute it and/or modify it under the *
1307+ * terms of the GNU Lesser General Public License as published by the Free *
1308+ * Software Foundation; either version 3 of the License, or (at your option) *
1309+ * any later version. *
1310+ * *
1311+ * This software is distributed in the hope that it will be useful, but *
1312+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
1313+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
1314+ * for more details. *
1315+ * *
1316+ * You should have received a copy of the GNU Lesser General Public License *
1317+ * along with software; if not, write to the Free Software Foundation, Inc., *
1318+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
1319+ * *
1320+ * CAnDL, the Chunky Dependence Analyser *
1321+ * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
1322+ * *
1323+ ******************************************************************************/
1324+
1325+#ifndef CANDL_H
1326+#define CANDL_H
1327+
1328+# include <candl/ddv.h>
1329+# include <candl/dependence.h>
1330+# include <candl/macros.h>
1331+# include <candl/matrix.h>
1332+# include <candl/options.h>
1333+# include <candl/piplib-wrapper.h>
1334+# include <candl/scop.h>
1335+# include <candl/statement.h>
1336+# include <candl/util.h>
1337+# include <candl/violation.h>
1338+
1339+#endif
1340diff --git a/include/candl/candl.h.in b/include/candl/candl.h.in
1341deleted file mode 100644
1342index 187981e..0000000
1343--- a/include/candl/candl.h.in
1344+++ /dev/null
1345@@ -1,160 +0,0 @@
1346-
1347- /**------ ( ----------------------------------------------------------**
1348- ** )\ CAnDL **
1349- **----- / ) --------------------------------------------------------**
1350- ** ( * ( candl.h **
1351- **---- \#/ --------------------------------------------------------**
1352- ** .-"#'-. First version: september 8th 2003 **
1353- **--- |"-.-"| -------------------------------------------------------**
1354- | |
1355- | |
1356- ******** | | *************************************************************
1357- * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
1358- ******************************************************************************
1359- * *
1360- * Copyright (C) 2003-2008 Cedric Bastoul *
1361- * *
1362- * This is free software; you can redistribute it and/or modify it under the *
1363- * terms of the GNU Lesser General Public License as published by the Free *
1364- * Software Foundation; either version 3 of the License, or (at your option) *
1365- * any later version. *
1366- * *
1367- * This software is distributed in the hope that it will be useful, but *
1368- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
1369- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
1370- * for more details. *
1371- * *
1372- * You should have received a copy of the GNU Lesser General Public License *
1373- * along with software; if not, write to the Free Software Foundation, Inc., *
1374- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
1375- * *
1376- * CAnDL, the Chunky Dependence Analyser *
1377- * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
1378- * *
1379- ******************************************************************************/
1380-
1381-
1382-/******************************************************************************
1383- * THIS FILE HAS BEEN AUTOMATICALLY GENERATED FROM candl.h.in BY configure *
1384- ******************************************************************************/
1385-
1386-
1387-#ifndef CANDL_H
1388-# define CANDL_H
1389-
1390-# define CANDL_RELEASE "@PACKAGE_VERSION@"
1391-# define CANDL_VERSION "@BITS@"
1392-@DEFINE_HAS_SCOPLIB_LIB@
1393-@DEFINE_HAS_ISL_LIB@
1394-
1395-
1396-# include <piplib/piplib@BITS@.h>
1397-# include <candl/options.h>
1398-# include <candl/matrix.h>
1399-# include <candl/statement.h>
1400-# include <candl/program.h>
1401-# include <candl/dependence.h>
1402-# include <candl/ddv.h>
1403-# include <candl/violation.h>
1404-# include <candl/pruning.h>
1405-
1406-# define CANDL_UNSET -1 /* Must be negative (we do use that property).
1407- * All other constants have to be different.
1408- */
1409-
1410-# define CANDL_RAW 1
1411-# define CANDL_WAR 2
1412-# define CANDL_WAW 3
1413-# define CANDL_RAR 4
1414-# define CANDL_RAW_SCALPRIV 5
1415-
1416-# define CANDL_ASSIGNMENT 1
1417-# define CANDL_P_REDUCTION 2
1418-# define CANDL_M_REDUCTION 3
1419-# define CANDL_T_REDUCTION 4
1420-
1421-# define CANDL_EQUAL 1
1422-# define CANDL_POSIT 2
1423-# define CANDL_LATER 3
1424-# define CANDL_NEVER 4
1425-
1426-# define CANDL_NB_INFOS 3
1427-
1428-# define CANDL_MAX_STRING 2048
1429-# define CANDL_TEMP_OUTPUT "candl.temp"
1430-
1431-/* Useful macros. */
1432-# define CANDL_max(x,y) ((x) > (y)? (x) : (y))
1433-# define CANDL_min(x,y) ((x) < (y)? (x) : (y))
1434-
1435-# define CANDL_FAIL(msg) { fprintf(stderr, "[Candl] " msg "\n"); exit(1); }
1436-
1437-/******************************************************************************
1438- * FORMAT *
1439- ******************************************************************************/
1440-#if defined(LINEAR_VALUE_IS_LONGLONG)
1441-#define CANDL_FMT "%4lld "
1442-#elif defined(LINEAR_VALUE_IS_LONG)
1443-#define CANDL_FMT "%4ld "
1444-#else /* GNUMP */
1445-#define CANDL_FMT "%4s"
1446-#endif
1447-
1448-/******************************************************************************
1449- * CANDL GMP MACROS *
1450- ******************************************************************************/
1451-#ifdef LINEAR_VALUE_IS_MP
1452-/* Basic Macros */
1453-#define CANDL_init(val) (mpz_init((val)))
1454-#define CANDL_assign(v1,v2) (mpz_set((v1),(v2)))
1455-#define CANDL_set_si(val,i) (mpz_set_si((val),(i)))
1456-#define CANDL_get_si(val) (mpz_get_si((val)))
1457-#define CANDL_clear(val) (mpz_clear((val)))
1458-#define CANDL_print(Dst,fmt,val) { char *str; \
1459- str = mpz_get_str(0,10,(val)); \
1460- fprintf((Dst),(fmt),str); free(str); \
1461- }
1462-
1463-/* Boolean operators on 'Value' or 'Entier' */
1464-#define CANDL_eq(v1,v2) (mpz_cmp((v1),(v2)) == 0)
1465-#define CANDL_ne(v1,v2) (mpz_cmp((v1),(v2)) != 0)
1466-
1467-/* Binary operators on 'Value' or 'Entier' */
1468-#define CANDL_increment(ref,val) (mpz_add_ui((ref),(val),1))
1469-#define CANDL_decrement(ref,val) (mpz_sub_ui((ref),(val),1))
1470-#define CANDL_subtract(ref,val1,val2) (mpz_sub((ref),(val1),(val2)))
1471-#define CANDL_oppose(ref,val) (mpz_neg((ref),(val)))
1472-
1473-/* Conditional operations on 'Value' or 'Entier' */
1474-#define CANDL_zero_p(val) (mpz_sgn(val) == 0)
1475-#define CANDL_notzero_p(val) (mpz_sgn(val) != 0)
1476-
1477-/******************************************************************************
1478- * CANDL BASIC TYPES MACROS *
1479- ******************************************************************************/
1480-#else
1481-/* Basic Macros */
1482-#define CANDL_init(val) ((val) = 0)
1483-#define CANDL_assign(v1,v2) ((v1) = (v2))
1484-#define CANDL_set_si(val,i) ((val) = (Entier)(i))
1485-#define CANDL_get_si(val) ((val))
1486-#define CANDL_clear(val) ((val) = 0)
1487-#define CANDL_print(Dst,fmt,val) (fprintf((Dst),(fmt),(val)))
1488-
1489-/* Boolean operators on 'Value' or 'Entier' */
1490-#define CANDL_eq(v1,v2) ((v1)==(v2))
1491-#define CANDL_ne(v1,v2) ((v1)!=(v2))
1492-
1493-/* Binary operators on 'Value' or 'Entier' */
1494-#define CANDL_increment(ref,val) ((ref) = (val)+(Entier)(1))
1495-#define CANDL_decrement(ref,val) ((ref) = (val)-(Entier)(1))
1496-#define CANDL_subtract(ref,val1,val2) ((ref) = (val1)-(val2))
1497-#define CANDL_oppose(ref,val) ((ref) = (-(val)))
1498-
1499-/* Conditional operations on 'Value' or 'Entier' */
1500-#define CANDL_zero_p(val) CANDL_eq(val,0)
1501-#define CANDL_notzero_p(val) CANDL_ne(val,0)
1502-
1503-#endif
1504-
1505-#endif // !CANDL_H
1506diff --git a/include/candl/ddv.h b/include/candl/ddv.h
1507index bbc97db..8ae9a61 100644
1508--- a/include/candl/ddv.h
1509+++ b/include/candl/ddv.h
1510@@ -38,26 +38,18 @@
1511 * \author Louis-Noel Pouchet
1512 */
1513
1514-
1515 #ifndef CANDL_DDV_H
1516 # define CANDL_DDV_H
1517
1518-
1519 # include <stdio.h>
1520-# include <candl/statement.h>
1521-# include <candl/matrix.h>
1522-# include <candl/program.h>
1523-# include <candl/options.h>
1524-# include <candl/dependence.h>
1525-
1526-
1527
1528 # if defined(__cplusplus)
1529 extern "C"
1530 {
1531 # endif
1532
1533-
1534+struct osl_scop;
1535+struct osl_dependence;
1536
1537 /******************************************************************************
1538 * Dependence Distance structures *
1539@@ -112,9 +104,6 @@ extern "C"
1540
1541 typedef struct candl_ddv CandlDDV;
1542
1543-
1544-
1545-
1546 /******************************************************************************
1547 * Memory deallocation function *
1548 ******************************************************************************/
1549@@ -127,7 +116,6 @@ extern "C"
1550 CandlDDV*
1551 candl_ddv_malloc();
1552
1553-
1554 /**
1555 * candl_ddv_alloc: Allocate a ddv for a loop of depth 'size'.
1556 *
1557@@ -136,7 +124,6 @@ candl_ddv_malloc();
1558 CandlDDV*
1559 candl_ddv_alloc(int);
1560
1561-
1562 /**
1563 * candl_ddv_free: Free a ddv.
1564 *
1565@@ -145,7 +132,6 @@ candl_ddv_alloc(int);
1566 void
1567 candl_ddv_free(CandlDDV*);
1568
1569-
1570 /**
1571 * candl_ddv_set_type_at: Set the type of a ddv component. Type is one of
1572 * '=', '>', '<', '*' or 'constant' as defined by the enum e_dv_type.
1573@@ -173,12 +159,10 @@ candl_ddv_set_value_at(CandlDDV*, int, int);
1574 void
1575 candl_ddv_set_deptype(CandlDDV*, int);
1576
1577-
1578 /******************************************************************************
1579 * Structure display function *
1580 ******************************************************************************/
1581
1582-
1583 /**
1584 * candl_ddv_print: print a ddv.
1585 *
1586@@ -186,7 +170,6 @@ candl_ddv_set_deptype(CandlDDV*, int);
1587 void
1588 candl_ddv_print(FILE*, CandlDDV*);
1589
1590-
1591 /******************************************************************************
1592 * Processing functions *
1593 ******************************************************************************/
1594@@ -199,7 +182,7 @@ candl_ddv_print(FILE*, CandlDDV*);
1595 *
1596 */
1597 CandlDDV*
1598-candl_ddv_extract_in_loop(CandlProgram*, CandlDependence*, int);
1599+candl_ddv_extract_in_loop(struct osl_scop*, struct osl_dependence*, int);
1600
1601 /**
1602 * candl_loops_are_permutable: output 1 if the 2 loops are permutable.
1603@@ -207,10 +190,7 @@ candl_ddv_extract_in_loop(CandlProgram*, CandlDependence*, int);
1604 *
1605 */
1606 int
1607-candl_loops_are_permutable(CandlProgram* program, CandlDependence* deps,
1608- int loop_id1, int loop_id2);
1609-
1610-
1611+candl_loops_are_permutable(struct osl_scop*, struct osl_dependence*, int, int);
1612
1613 # if defined(__cplusplus)
1614 }
1615diff --git a/include/candl/dependence.h b/include/candl/dependence.h
1616index 0f40e65..9205de4 100644
1617--- a/include/candl/dependence.h
1618+++ b/include/candl/dependence.h
1619@@ -33,153 +33,99 @@
1620 * *
1621 ******************************************************************************/
1622
1623-
1624 #ifndef CANDL_DEPENDENCE_H
1625 # define CANDL_DEPENDENCE_H
1626
1627-
1628 # include <stdio.h>
1629-# include <candl/statement.h>
1630-# include <candl/matrix.h>
1631-# include <candl/program.h>
1632 # include <candl/options.h>
1633
1634-
1635-
1636-# define CANDL_ARRAY_BUFF_SIZE 2048
1637-# define CANDL_VAR_UNDEF 1
1638-# define CANDL_VAR_IS_DEF 2
1639-# define CANDL_VAR_IS_USED 3
1640-# define CANDL_VAR_IS_DEF_USED 4
1641-
1642+# define CANDL_ARRAY_BUFF_SIZE 2048
1643+# define CANDL_VAR_UNDEF 1
1644+# define CANDL_VAR_IS_DEF 2
1645+# define CANDL_VAR_IS_USED 3
1646+# define CANDL_VAR_IS_DEF_USED 4
1647
1648 # if defined(__cplusplus)
1649 extern "C"
1650 {
1651 # endif
1652
1653-
1654-/**
1655- * CandlDependence structure:
1656- * this structure contains all the informations about a data dependence, it is
1657- * also a node of the linked list of all dependences of the dependence graph.
1658- */
1659-struct candldependence
1660-{ CandlStatement * source; /**< Pointer to source statement. */
1661- CandlStatement * target; /**< Pointer to target statement. */
1662- int depth; /**< Dependence level. */
1663- int type; /**< Dependence type: a dependence from source
1664- * to target can be:
1665- * - CANDL_UNSET if the dependence type is
1666- * still not set,
1667- * - CANDL_RAW if source writes M and
1668- * target read M (flow-dependence),
1669- * - CANDL_WAR if source reads M and
1670- * target writes M (anti-dependence),
1671- * - CANDL_WAW if source writes M and
1672- * target writes M too (output-dependence)
1673- * - CANDL_RAR if source reads M and
1674- * target reads M too (input-dependence).
1675- */
1676- int ref_source; /**< Position of source reference. */
1677- int ref_target; /**< Position of target reference. */
1678- CandlMatrix * domain; /**< Dependence polyhedron. */
1679-
1680- void* usr; /**< User field, for library users
1681- convenience. */
1682- struct candldependence * next; /**< Pointer to next dependence */
1683-};
1684-typedef struct candldependence CandlDependence;
1685-typedef struct candldependence candl_dependence_t;
1686-typedef struct candldependence * candl_dependence_p;
1687-
1688-
1689-/******************************************************************************
1690- * Structure display function *
1691- ******************************************************************************/
1692-void candl_dependence_print_structure(FILE *, candl_dependence_p, int);
1693-void candl_dependence_print(FILE *, candl_dependence_p);
1694-void candl_dependence_pprint(FILE *, candl_dependence_p);
1695-void candl_dependence_view(candl_dependence_p);
1696-# ifdef CANDL_SUPPORTS_SCOPLIB
1697-CandlDependence* candl_dependence_read_from_scop(scoplib_scop_p, CandlProgram*);
1698-void candl_dependence_update_scop_with_deps(scoplib_scop_p, CandlDependence*);
1699-void candl_dependence_print_scop(FILE*, FILE*, CandlDependence*);
1700-# endif
1701+struct osl_relation;
1702+struct osl_statement;
1703+struct osl_scop;
1704+struct osl_dependence;
1705
1706 #ifdef CANDL_SUPPORTS_ISL
1707-CandlDependence* candl_dependence_isl_simplify(CandlDependence*, CandlProgram*);
1708+struct osl_dependence* candl_dependence_isl_simplify(struct osl_dependence*,
1709+ struct osl_scop*);
1710 # endif
1711
1712-
1713-/******************************************************************************
1714- * Memory alloc/dealloc function *
1715- ******************************************************************************/
1716-candl_dependence_p candl_dependence_malloc();
1717-void candl_dependence_free(candl_dependence_p);
1718-
1719+/*+***************************************************************************
1720+ * Structure display function *
1721+ *****************************************************************************/
1722+void candl_dependence_pprint(FILE*, struct osl_dependence*);
1723+void candl_dependence_view(struct osl_dependence*);
1724
1725 /******************************************************************************
1726 * Processing functions *
1727 ******************************************************************************/
1728-int candl_dependence_gcd_test(CandlStatement*,
1729- CandlStatement*,
1730- CandlMatrix*, int);
1731-int candl_dependence_check(CandlProgram *,
1732- candl_dependence_p,
1733- CandlOptions *);
1734-candl_dependence_p candl_dependence(CandlProgram *, CandlOptions *);
1735-
1736+int candl_dependence_gcd_test(struct osl_statement*,
1737+ struct osl_statement*,
1738+ struct osl_relation*, int);
1739+int candl_dependence_check(struct osl_scop*,
1740+ struct osl_dependence*,
1741+ candl_options_p);
1742+struct osl_dependence* candl_dependence(struct osl_scop*, candl_options_p);
1743+void candl_dependence_add_extension(struct osl_scop*,
1744+ candl_options_p);
1745+
1746+/*+***************************************************************************
1747+ * Memory allocation/deallocation function *
1748+ *****************************************************************************/
1749+void candl_dependence_init_fields(struct osl_scop*,
1750+ struct osl_dependence*);
1751
1752 /******************************************************************************
1753 * Scalar analysis functions *
1754 ******************************************************************************/
1755-int
1756-candl_dependence_var_is_scalar (candl_program_p, int);
1757-
1758-CandlStatement**
1759-candl_dependence_refvar_chain(candl_program_p, CandlStatement*, int, int);
1760-
1761-int
1762-candl_dependence_var_is_ref(CandlStatement*, int);
1763-
1764-int
1765-candl_dependence_check_domain_is_included(CandlStatement*, CandlStatement*,
1766- CandlMatrix*, int);
1767-
1768-int
1769-candl_dependence_scalar_is_privatizable_at(candl_program_p, int, int);
1770-
1771-int
1772-candl_dependence_is_loop_carried (candl_program_p, CandlDependence*, int);
1773-
1774-void
1775-candl_dependence_prune_scalar_waw (candl_program_p, CandlOptions*,
1776- CandlDependence**);
1777-
1778-void
1779-candl_dependence_prune_with_privatization (candl_program_p, CandlOptions*,
1780- CandlDependence**);
1781-
1782-int
1783-candl_dependence_scalar_renaming(candl_program_p, CandlOptions*,
1784- CandlDependence**);
1785-
1786-int
1787-candl_dependence_analyze_scalars(candl_program_p, CandlOptions*);
1788+int candl_dependence_var_is_scalar(struct osl_scop*, int);
1789+struct osl_statement** candl_dependence_refvar_chain(struct osl_scop*,
1790+ struct osl_statement*, int, int);
1791+int candl_dependence_var_is_ref(struct osl_statement*, int);
1792+int candl_dependence_check_domain_is_included(
1793+ struct osl_statement*,
1794+ struct osl_statement*,
1795+ struct osl_relation*, int);
1796+int candl_dependence_scalar_is_privatizable_at(
1797+ struct osl_scop*, int, int);
1798+int candl_dependence_is_loop_carried(struct osl_scop*,
1799+ struct osl_dependence*, int);
1800+void candl_dependence_prune_scalar_waw(struct osl_scop*,
1801+ candl_options_p,
1802+ struct osl_dependence**);
1803+void candl_dependence_prune_with_privatization(
1804+ struct osl_scop*,
1805+ candl_options_p,
1806+ struct osl_dependence**);
1807+int candl_dependence_scalar_renaming(struct osl_scop*,
1808+ candl_options_p,
1809+ struct osl_dependence**);
1810+int candl_dependence_analyze_scalars(struct osl_scop*,
1811+ candl_options_p);
1812
1813 /******************************************************************************
1814 * Miscellaneous functions *
1815 ******************************************************************************/
1816-int
1817-candl_num_dependences(CandlDependence *candl_deps);
1818-
1819-void
1820-candl_compute_last_writer (CandlDependence *dep, CandlProgram *prog);
1821+struct osl_relation* candl_dependence_get_relation_ref_source_in_dep(
1822+ struct osl_dependence*);
1823+struct osl_relation* candl_dependence_get_relation_ref_target_in_dep(
1824+ struct osl_dependence*);
1825+int candl_num_dependences(struct osl_dependence*);
1826+void candl_compute_last_writer(struct osl_dependence*,
1827+ struct osl_scop*);
1828+struct osl_dependence* candl_dependence_prune_transitively_covered(
1829+ struct osl_dependence*);
1830
1831-CandlDependence*
1832-candl_dependence_prune_transitively_covered (CandlDependence* deps);
1833-
1834 # if defined(__cplusplus)
1835 }
1836 # endif
1837diff --git a/include/candl/macros.h.in b/include/candl/macros.h.in
1838new file mode 100644
1839index 0000000..def4643
1840--- /dev/null
1841+++ b/include/candl/macros.h.in
1842@@ -0,0 +1,160 @@
1843+
1844+ /**------ ( ----------------------------------------------------------**
1845+ ** )\ CAnDL **
1846+ **----- / ) --------------------------------------------------------**
1847+ ** ( * ( candl.h **
1848+ **---- \#/ --------------------------------------------------------**
1849+ ** .-"#'-. First version: september 8th 2003 **
1850+ **--- |"-.-"| -------------------------------------------------------**
1851+ | |
1852+ | |
1853+ ******** | | *************************************************************
1854+ * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
1855+ ******************************************************************************
1856+ * *
1857+ * Copyright (C) 2003-2008 Cedric Bastoul *
1858+ * *
1859+ * This is free software; you can redistribute it and/or modify it under the *
1860+ * terms of the GNU Lesser General Public License as published by the Free *
1861+ * Software Foundation; either version 3 of the License, or (at your option) *
1862+ * any later version. *
1863+ * *
1864+ * This software is distributed in the hope that it will be useful, but *
1865+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
1866+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
1867+ * for more details. *
1868+ * *
1869+ * You should have received a copy of the GNU Lesser General Public License *
1870+ * along with software; if not, write to the Free Software Foundation, Inc., *
1871+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
1872+ * *
1873+ * CAnDL, the Chunky Dependence Analyser *
1874+ * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
1875+ * *
1876+ ******************************************************************************/
1877+
1878+
1879+/******************************************************************************
1880+ * THIS FILE HAS BEEN AUTOMATICALLY GENERATED FROM macros.h.in BY configure *
1881+ ******************************************************************************/
1882+
1883+#ifndef CANDL_MACROS_H
1884+# define CANDL_MACROS_H
1885+
1886+# define CANDL_EQUAL 1
1887+# define CANDL_POSIT 2
1888+# define CANDL_LATER 3
1889+# define CANDL_NEVER 4
1890+
1891+# define CANDL_NB_INFOS 3
1892+
1893+# define CANDL_MAX_STRING 2048
1894+# define CANDL_TEMP_OUTPUT "candl.temp"
1895+
1896+# define CANDL_RELEASE "@PACKAGE_VERSION@"
1897+# define CANDL_VERSION "@BITS@"
1898+@DEFINE_HAS_ISL_LIB@
1899+
1900+/* Useful macros. */
1901+# define CANDL_max(x,y) ((x) > (y)? (x) : (y))
1902+# define CANDL_min(x,y) ((x) < (y)? (x) : (y))
1903+
1904+# define CANDL_info(msg) \
1905+ do { \
1906+ fprintf(stderr,"[Candl] Info: "msg" (%s).\n", __func__); \
1907+ } while (0)
1908+
1909+# define CANDL_warning(msg) \
1910+ do { \
1911+ fprintf(stderr,"[Candl] Warning: "msg" (%s).\n", __func__); \
1912+ } while (0)
1913+
1914+# define CANDL_error(msg) \
1915+ do { \
1916+ fprintf(stderr,"[Candl] Error: "msg" (%s).\n", __func__); \
1917+ exit(1); \
1918+ } while (0)
1919+
1920+# define CANDL_malloc(ptr, type, size) \
1921+ do { \
1922+ if (((ptr) = (type)malloc(size)) == NULL) \
1923+ CANDL_error("memory overflow"); \
1924+ } while (0)
1925+
1926+# define CANDL_realloc(ptr, type, size) \
1927+ do { \
1928+ if (((ptr) = (type)realloc(ptr, size)) == NULL) \
1929+ CANDL_error("memory overflow"); \
1930+ } while (0)
1931+
1932+# define CANDL_fail(msg) { fprintf(stderr, "[Candl] " msg "\n"); exit(1); }
1933+
1934+/******************************************************************************
1935+ * FORMAT *
1936+ ******************************************************************************/
1937+#if defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
1938+#define CANDL_FMT "%4lld "
1939+#elif defined(CANDL_LINEAR_VALUE_IS_LONG)
1940+#define CANDL_FMT "%4ld "
1941+#else /* GNUMP */
1942+#define CANDL_FMT "%4s"
1943+#endif
1944+
1945+/******************************************************************************
1946+ * CANDL GMP MACROS *
1947+ ******************************************************************************/
1948+#ifdef CANDL_LINEAR_VALUE_IS_MP
1949+/* Basic Macros */
1950+#define CANDL_init(val) (mpz_init((val)))
1951+#define CANDL_assign(v1,v2) (mpz_set((v1),(v2)))
1952+#define CANDL_set_si(val,i) (mpz_set_si((val),(i)))
1953+#define CANDL_get_si(val) (mpz_get_si((val)))
1954+#define CANDL_clear(val) (mpz_clear((val)))
1955+#define CANDL_print(Dst,fmt,val) { char *str; \
1956+ str = mpz_get_str(0,10,(val)); \
1957+ fprintf((Dst),(fmt),str); free(str); \
1958+ }
1959+
1960+/* Boolean operators on 'Value' or 'Entier' */
1961+#define CANDL_eq(v1,v2) (mpz_cmp((v1),(v2)) == 0)
1962+#define CANDL_ne(v1,v2) (mpz_cmp((v1),(v2)) != 0)
1963+
1964+/* Binary operators on 'Value' or 'Entier' */
1965+#define CANDL_increment(ref,val) (mpz_add_ui((ref),(val),1))
1966+#define CANDL_decrement(ref,val) (mpz_sub_ui((ref),(val),1))
1967+#define CANDL_subtract(ref,val1,val2) (mpz_sub((ref),(val1),(val2)))
1968+#define CANDL_oppose(ref,val) (mpz_neg((ref),(val)))
1969+
1970+/* Conditional operations on 'Value' or 'Entier' */
1971+#define CANDL_zero_p(val) (mpz_sgn(val) == 0)
1972+#define CANDL_notzero_p(val) (mpz_sgn(val) != 0)
1973+
1974+/******************************************************************************
1975+ * CANDL BASIC TYPES MACROS *
1976+ ******************************************************************************/
1977+#else
1978+/* Basic Macros */
1979+#define CANDL_init(val) ((val) = 0)
1980+#define CANDL_assign(v1,v2) ((v1) = (v2))
1981+#define CANDL_set_si(val,i) ((val) = (Entier)(i))
1982+#define CANDL_get_si(val) ((val))
1983+#define CANDL_clear(val) ((val) = 0)
1984+#define CANDL_print(Dst,fmt,val) (fprintf((Dst),(fmt),(val)))
1985+
1986+/* Boolean operators on 'Value' or 'Entier' */
1987+#define CANDL_eq(v1,v2) ((v1)==(v2))
1988+#define CANDL_ne(v1,v2) ((v1)!=(v2))
1989+
1990+/* Binary operators on 'Value' or 'Entier' */
1991+#define CANDL_increment(ref,val) ((ref) = (val)+(Entier)(1))
1992+#define CANDL_decrement(ref,val) ((ref) = (val)-(Entier)(1))
1993+#define CANDL_subtract(ref,val1,val2) ((ref) = (val1)-(val2))
1994+#define CANDL_oppose(ref,val) ((ref) = (-(val)))
1995+
1996+/* Conditional operations on 'Value' or 'Entier' */
1997+#define CANDL_zero_p(val) CANDL_eq(val,0)
1998+#define CANDL_notzero_p(val) CANDL_ne(val,0)
1999+
2000+#endif
2001+
2002+#endif // !CANDL_MACROS_H
2003diff --git a/include/candl/matrix.h b/include/candl/matrix.h
2004index 7bbc13b..60e525f 100644
2005--- a/include/candl/matrix.h
2006+++ b/include/candl/matrix.h
2007@@ -33,92 +33,26 @@
2008 * *
2009 ******************************************************************************/
2010
2011-
2012 #ifndef CANDL_MATRIX_H
2013 # define CANDL_MATRIX_H
2014
2015-# include <stdio.h>
2016-# include <piplib/piplib.h>
2017-
2018-# ifdef LINEAR_VALUE_IS_LONG
2019-# define CLAN_INT_T_IS_LONG
2020-# endif
2021-# ifdef LINEAR_VALUE_IS_LONGLONG
2022-# define CLAN_INT_T_IS_LONGLONG
2023-# endif
2024-# ifdef LINEAR_VALUE_IS_MP
2025-# define CLAN_INT_T_IS_MP
2026-# endif
2027+# include <candl/violation.h>
2028
2029 # if defined(__cplusplus)
2030 extern "C"
2031 {
2032 # endif
2033
2034+struct osl_relation;
2035+struct osl_dependence;
2036
2037-/**
2038- * The matrix structure comes directly from PipLib (defined in piplib/piplib.h)
2039- * which is directly the PolyLib Matrix (defined in polylib/types.h)
2040- * here is how it looks like (at least in PipLib 1.3.5 version):
2041- *
2042- * struct pipmatrix
2043- * { unsigned NbRows; // The number of rows (= NbConstraints in Polyhedron).
2044- * unsigned NbColumns; // The number of columns (= Dimension+2 in Polyhedron).
2045- * Value **p; // An array of pointers to the beginning of each row.
2046- * Value *p_Init; // The matrix is stored here, contiguously in memory.
2047- * int p_Init_size; // Needed to free the memory allocated by mpz_init.
2048- * } ;
2049- * typedef struct pipmatrix PipMatrix ;
2050- */
2051-
2052-typedef PipMatrix CandlMatrix;
2053-
2054-
2055-/**
2056- * CandlMatrixList structure:
2057- * this structure reprensents a node of a linked list of CandlMatrix structures.
2058- */
2059-struct candlmatrixlist
2060-{ CandlMatrix * matrix; /**< An element of the list. */
2061- struct candlmatrixlist * next;/**< Pointer to the next element of the list.*/
2062-};
2063-typedef struct candlmatrixlist CandlMatrixList;
2064-
2065-
2066-/******************************************************************************
2067- * Structure display function *
2068- ******************************************************************************/
2069-void candl_matrix_print_structure(FILE *, CandlMatrix *, int);
2070-void candl_matrix_print(FILE *, CandlMatrix *);
2071-void candl_matrix_print_data(FILE *, CandlMatrix *);
2072-void candl_matrix_list_print_structure(FILE *, CandlMatrixList *, int);
2073-void candl_matrix_list_print(FILE *, CandlMatrixList *);
2074-
2075-/******************************************************************************
2076- * Memory deallocation function *
2077- ******************************************************************************/
2078-void candl_matrix_free(CandlMatrix *);
2079-void candl_matrix_list_free(CandlMatrixList *);
2080-
2081-
2082-/******************************************************************************
2083- * Reading functions *
2084- ******************************************************************************/
2085-CandlMatrix * candl_matrix_read(FILE *);
2086-CandlMatrixList * candl_matrix_list_read(FILE *);
2087-
2088-
2089-/******************************************************************************
2090- * Processing functions *
2091- ******************************************************************************/
2092-CandlMatrix * candl_matrix_malloc(int, int);
2093-CandlMatrixList * candl_matrix_list_malloc();
2094-CandlMatrix * candl_matrix_violation(CandlMatrix *, CandlMatrix *,
2095- CandlMatrix *, int, int);
2096-int candl_matrix_check_point (CandlMatrix* , CandlMatrix* );
2097+candl_violation_p candl_matrix_violation(struct osl_dependence*,
2098+ struct osl_relation*, struct osl_relation*,
2099+ int, int);
2100+int candl_matrix_check_point(struct osl_relation*,
2101+ struct osl_relation*);
2102
2103 # if defined(__cplusplus)
2104 }
2105 # endif
2106-#endif /* define CANDL_DEPENDENCE_H */
2107-
2108+#endif
2109diff --git a/include/candl/options.h b/include/candl/options.h
2110index e62fddb..7154cb5 100644
2111--- a/include/candl/options.h
2112+++ b/include/candl/options.h
2113@@ -33,7 +33,6 @@
2114 * *
2115 ******************************************************************************/
2116
2117-
2118 #ifndef CANDL_OPTIONS_H
2119 # define CANDL_OPTIONS_H
2120
2121@@ -44,60 +43,55 @@ extern "C"
2122 {
2123 # endif
2124
2125-
2126 /**
2127- * CandlOptions structure:
2128+ * candl_options structure:
2129 * this structure contains all the informations on the state of Candl options.
2130 */
2131-struct candloptions
2132-{ /* OPTIONS FOR DEPENDENCE COMPUTATION */
2133+struct candl_options {
2134+ /* OPTIONS FOR DEPENDENCE COMPUTATION */
2135 int waw; /**< 1 if write after write (output) dependences matter. */
2136 int raw; /**< 1 if read after write (flow) dependences matter. */
2137 int war; /**< 1 if write after read (anti) dependences matter. */
2138 int rar; /**< 1 if read after read (input) dependences matter. */
2139 int commute; /**< 1 to use commutativity to simplify dependences. */
2140 int fullcheck; /**< 1 to compute all dependence violations. */
2141- int depgraph; /**< 1 to print the dependence graph. */
2142- int violgraph; /**< 1 to print the violation graph. */
2143 int scalar_renaming; /**< 1 to enable scalar renaming. */
2144 int scalar_privatization; /**< 1 to enable scalar privatization. */
2145 int scalar_expansion; /**< 1 to enable scalar privatization. */
2146 int lastwriter; /**< 1 to compute last writer */
2147- int readscop; /**< 1 to enable reading from a .scop formatted file. */
2148- int writescop; /**< 1 to enable writing to a .scop formatted file. */
2149- int scoptocandl; /**< 1 to act as a .scop to candl converter. */
2150 int verbose; /**< 1 to enable verbose output. */
2151+ int outscop; /**< 1 to print the scop with dependences. */
2152+ int autocorrect; /**< 1 to correct violations. fullcheck is set to 1 and
2153+ * the -test is required.
2154+ */
2155 /* UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY */
2156 int view; /**< 1 to call dot and gv to visualize the graphs. */
2157 int structure; /**< 1 to print internal dependence structure. */
2158 int prune_dups; /**< 1 to use experimental dependence pruning algorithm. */
2159-} ;
2160-typedef struct candloptions CandlOptions;
2161+};
2162
2163+typedef struct candl_options candl_options_t;
2164+typedef struct candl_options* candl_options_p;
2165
2166 /******************************************************************************
2167 * Structure display function *
2168 ******************************************************************************/
2169-void candl_options_print(FILE *, CandlOptions *);
2170-
2171+void candl_options_print(FILE *, candl_options_p);
2172
2173 /******************************************************************************
2174 * Memory deallocation function *
2175 ******************************************************************************/
2176-void candl_options_free(CandlOptions *);
2177-
2178+void candl_options_free(candl_options_p);
2179
2180 /******************************************************************************
2181 * Reading function *
2182 ******************************************************************************/
2183-void candl_options_read(int, char **, FILE **, FILE **, CandlOptions **);
2184-
2185+void candl_options_read(int, char **, FILE **, FILE **, FILE**, candl_options_p*);
2186
2187 /******************************************************************************
2188 * Processing functions *
2189 ******************************************************************************/
2190-CandlOptions * candl_options_malloc(void);
2191-
2192+candl_options_p candl_options_malloc(void);
2193
2194 #if defined(__cplusplus)
2195 }
2196diff --git a/include/candl/piplib-wrapper.h b/include/candl/piplib-wrapper.h
2197index 27576f5..642e366 100644
2198--- a/include/candl/piplib-wrapper.h
2199+++ b/include/candl/piplib-wrapper.h
2200@@ -41,23 +41,27 @@
2201 #ifndef CANDL_PIPLIB_WRAPPER_H
2202 # define CANDL_PIPLIB_WRAPPER_H
2203
2204-
2205-# include <stdio.h>
2206-# include <candl/matrix.h>
2207-
2208-
2209-
2210 # if defined(__cplusplus)
2211 extern "C"
2212 {
2213 # endif
2214-
2215
2216-int
2217-pip_has_rational_point(PipMatrix* system,
2218- PipMatrix* context,
2219- int conservative);
2220-
2221+struct osl_relation;
2222+struct pipmatrix;
2223+struct pipquast;
2224+struct pipoptions;
2225+struct piplist;
2226+
2227+struct pipmatrix* pip_relation2matrix(struct osl_relation*);
2228+struct osl_relation* pip_matrix2relation(struct pipmatrix*);
2229+int pip_has_rational_point(struct osl_relation*,
2230+ struct osl_relation*, int);
2231+struct pipquast* pip_solve_osl(struct osl_relation*, struct osl_relation*,
2232+ int, struct pipoptions*);
2233+int piplist_are_equal(struct piplist*, struct piplist*, int);
2234+struct osl_relation* pip_quast_to_polyhedra(struct pipquast*, int, int);
2235+struct osl_relation* pip_quast_no_solution_to_polyhedra(struct pipquast*,
2236+ int, int);
2237
2238 # if defined(__cplusplus)
2239 }
2240diff --git a/include/candl/piplib.h.in b/include/candl/piplib.h.in
2241new file mode 100644
2242index 0000000..dfaf33a
2243--- /dev/null
2244+++ b/include/candl/piplib.h.in
2245@@ -0,0 +1,51 @@
2246+
2247+ /**------ ( ----------------------------------------------------------**
2248+ ** )\ CAnDL **
2249+ **----- / ) --------------------------------------------------------**
2250+ ** ( * ( piplib.h **
2251+ **---- \#/ --------------------------------------------------------**
2252+ ** .-"#'-. First version: August 5th 2014 **
2253+ **--- |"-.-"| -------------------------------------------------------**
2254+ | |
2255+ | |
2256+ ******** | | *************************************************************
2257+ * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
2258+ ******************************************************************************
2259+ * *
2260+ * Copyright (C) 2003-2008 Cedric Bastoul *
2261+ * *
2262+ * This is free software; you can redistribute it and/or modify it under the *
2263+ * terms of the GNU Lesser General Public License as published by the Free *
2264+ * Software Foundation; either version 3 of the License, or (at your option) *
2265+ * any later version. *
2266+ * *
2267+ * This software is distributed in the hope that it will be useful, but *
2268+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
2269+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
2270+ * for more details. *
2271+ * *
2272+ * You should have received a copy of the GNU Lesser General Public License *
2273+ * along with software; if not, write to the Free Software Foundation, Inc., *
2274+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
2275+ * *
2276+ * CAnDL, the Chunky Dependence Analyzer *
2277+ * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
2278+ * *
2279+ ******************************************************************************/
2280+
2281+
2282+#ifndef CANDL_PIPLIB_H
2283+# define CANDL_PIPLIB_H
2284+
2285+# if defined(__cplusplus)
2286+extern "C"
2287+ {
2288+# endif
2289+
2290+# include <piplib/piplib@BITS@.h>
2291+
2292+# if defined(__cplusplus)
2293+ }
2294+# endif
2295+#endif /* define CANDL_PIPLIB_H */
2296+
2297diff --git a/include/candl/program.h b/include/candl/program.h
2298deleted file mode 100644
2299index 073016a..0000000
2300--- a/include/candl/program.h
2301+++ /dev/null
2302@@ -1,113 +0,0 @@
2303-
2304- /**------ ( ----------------------------------------------------------**
2305- ** )\ CAnDL **
2306- **----- / ) --------------------------------------------------------**
2307- ** ( * ( program.h **
2308- **---- \#/ --------------------------------------------------------**
2309- ** .-"#'-. First version: september 9th 2003 **
2310- **--- |"-.-"| -------------------------------------------------------**
2311- | |
2312- | |
2313- ******** | | *************************************************************
2314- * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
2315- ******************************************************************************
2316- * *
2317- * Copyright (C) 2003-2008 Cedric Bastoul *
2318- * *
2319- * This is free software; you can redistribute it and/or modify it under the *
2320- * terms of the GNU General Public License as published by the Free Software *
2321- * Foundation; either version 2 of the License, or (at your option) any later *
2322- * version. *
2323- * *
2324- * This software is distributed in the hope that it will be useful, but *
2325- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
2326- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
2327- * for more details. *
2328- * *
2329- * You should have received a copy of the GNU General Public License along *
2330- * with software; if not, write to the Free Software Foundation, Inc., *
2331- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
2332- * *
2333- * CAnDL, the Chunky Dependence Analyzer *
2334- * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
2335- * *
2336- ******************************************************************************/
2337-
2338-
2339-#ifndef CANDL_PROGRAM_H
2340-# define CANDL_PROGRAM_H
2341-
2342-# include <stdio.h>
2343-# include <stdlib.h>
2344-# include <candl/matrix.h>
2345-# include <candl/statement.h>
2346-
2347-# ifdef CANDL_SUPPORTS_SCOPLIB
2348-# include <scoplib/scop.h>
2349-# endif
2350-
2351-
2352-# if defined(__cplusplus)
2353-extern "C"
2354- {
2355-# endif
2356-
2357-/**
2358- * candl_program_t structure:
2359- * this structure contains all the informations about a program.
2360- */
2361-struct candl_program
2362-{
2363- CandlMatrix * context; /**< The context of the program. */
2364- int nb_statements; /**< The number of statements. */
2365- CandlStatement ** statement; /**< Array of nb_statements pointers on
2366- * the statements of the program.
2367- */
2368- CandlMatrix ** transformation; /**< Array of nb_statements pointers on
2369- * the transformation candidate (one
2370- * function per statement). If NULL:
2371- * no tranformation candidate.
2372- */
2373- int* scalars_privatizable;
2374-};
2375-typedef struct candl_program CandlProgram;
2376-typedef struct candl_program candl_program_t;
2377-typedef struct candl_program * candl_program_p;
2378-
2379-
2380-/******************************************************************************
2381- * Structure display function *
2382- ******************************************************************************/
2383-void candl_program_print_structure(FILE *, candl_program_p, int);
2384-void candl_program_print(FILE *, candl_program_p);
2385-void candl_program_print_candl_file(FILE *, candl_program_p);
2386-
2387-/******************************************************************************
2388- * Memory alloc/dealloc function *
2389- ******************************************************************************/
2390-candl_program_p candl_program_malloc();
2391-void candl_program_free(candl_program_p);
2392-
2393-
2394-/******************************************************************************
2395- * Reading function *
2396- ******************************************************************************/
2397-candl_program_p candl_program_read(FILE *);
2398-/* This function is compiled if candl was configured with CLAN support. */
2399-# ifdef CANDL_SUPPORTS_SCOPLIB
2400-candl_program_p candl_program_read_scop(FILE *);
2401-# endif
2402-
2403-/******************************************************************************
2404- * Processing functions *
2405- ******************************************************************************/
2406-/* This function is compiled if candl was configured with CLAN support. */
2407-# ifdef CANDL_SUPPORTS_SCOPLIB
2408-candl_program_p candl_program_convert_scop(scoplib_scop_p, int**);
2409-# endif
2410-
2411-# if defined(__cplusplus)
2412- }
2413-# endif
2414-#endif /* define CANDL_PROGRAM_H */
2415-
2416diff --git a/include/candl/pruning.h b/include/candl/pruning.h
2417deleted file mode 100644
2418index ad75e38..0000000
2419--- a/include/candl/pruning.h
2420+++ /dev/null
2421@@ -1,65 +0,0 @@
2422-
2423- /**------ ( ----------------------------------------------------------**
2424- ** )\ CAnDL **
2425- **----- / ) --------------------------------------------------------**
2426- ** ( * ( pruning.h **
2427- **---- \#/ --------------------------------------------------------**
2428- ** .-"#'-. First version: July 17th 2011 **
2429- **--- |"-.-"| -------------------------------------------------------**
2430- | |
2431- | |
2432- ******** | | *************************************************************
2433- * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
2434- ******************************************************************************
2435- * *
2436- * Copyright (C) 2003-2008 Cedric Bastoul *
2437- * *
2438- * This is free software; you can redistribute it and/or modify it under the *
2439- * terms of the GNU General Public License as published by the Free Software *
2440- * Foundation; either version 2 of the License, or (at your option) any later *
2441- * version. *
2442- * *
2443- * This software is distributed in the hope that it will be useful, but *
2444- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
2445- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
2446- * for more details. *
2447- * *
2448- * You should have received a copy of the GNU General Public License along *
2449- * with software; if not, write to the Free Software Foundation, Inc., *
2450- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
2451- * *
2452- * CAnDL, the Chunky Dependence Analyzer *
2453- * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
2454- * *
2455- ******************************************************************************/
2456-
2457-/**
2458- * \file pruning.h
2459- * \author Louis-Noel Pouchet
2460- */
2461-
2462-#ifndef CANDL_PRUNING_H
2463-# define CANDL_PRUNING_H
2464-
2465-
2466-# include <stdio.h>
2467-# include <candl/statement.h>
2468-# include <candl/matrix.h>
2469-# include <candl/program.h>
2470-# include <candl/options.h>
2471-# include <candl/matrix.h>
2472-
2473-
2474-# if defined(__cplusplus)
2475-extern "C"
2476- {
2477-# endif
2478-
2479-CandlDependence*
2480-candl_dependence_prune_transitively_covered (CandlDependence* deps);
2481-
2482-# if defined(__cplusplus)
2483- }
2484-# endif
2485-#endif /* define CANDL_PRUNING_H */
2486-
2487diff --git a/include/candl/scop.h b/include/candl/scop.h
2488new file mode 100644
2489index 0000000..ead43ed
2490--- /dev/null
2491+++ b/include/candl/scop.h
2492@@ -0,0 +1,66 @@
2493+
2494+ /**------ ( ----------------------------------------------------------**
2495+ ** )\ CAnDL **
2496+ **----- / ) --------------------------------------------------------**
2497+ ** ( * ( scop.h **
2498+ **---- \#/ --------------------------------------------------------**
2499+ ** .-"#'-. First version: july 9th 2012 **
2500+ **--- |"-.-"| -------------------------------------------------------**
2501+ | |
2502+ | |
2503+ ******** | | *************************************************************
2504+ * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
2505+ ******************************************************************************
2506+ * *
2507+ * Copyright (C) 2003-2008 Cedric Bastoul *
2508+ * *
2509+ * This is free software; you can redistribute it and/or modify it under the *
2510+ * terms of the GNU General Public License as published by the Free Software *
2511+ * Foundation; either version 2 of the License, or (at your option) any later *
2512+ * version. *
2513+ * *
2514+ * This software is distributed in the hope that it will be useful, but *
2515+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
2516+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
2517+ * for more details. *
2518+ * *
2519+ * You should have received a copy of the GNU General Public License along *
2520+ * with software; if not, write to the Free Software Foundation, Inc., *
2521+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
2522+ * *
2523+ * CAnDL, the Chunky Dependence Analyzer *
2524+ * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
2525+ * *
2526+ ******************************************************************************/
2527+
2528+/*
2529+ * author Joel Poudroux
2530+ */
2531+
2532+#ifndef CANDL_SCOP_H
2533+# define CANDL_SCOP_H
2534+
2535+# if defined(__cplusplus)
2536+extern "C"
2537+ {
2538+# endif
2539+
2540+struct osl_scop;
2541+
2542+struct candl_scop_usr {
2543+ int size;
2544+ int *scalars_privatizable;
2545+ void *usr_backup; /**< If there is already a usr field, it will be saved */
2546+};
2547+
2548+typedef struct candl_scop_usr candl_scop_usr_t;
2549+typedef struct candl_scop_usr* candl_scop_usr_p;
2550+
2551+void candl_scop_usr_init(struct osl_scop*);
2552+void candl_scop_usr_cleanup(struct osl_scop*);
2553+
2554+# if defined(__cplusplus)
2555+ }
2556+# endif
2557+
2558+#endif
2559diff --git a/include/candl/statement.h b/include/candl/statement.h
2560index 9e434a4..a26eff6 100644
2561--- a/include/candl/statement.h
2562+++ b/include/candl/statement.h
2563@@ -4,7 +4,7 @@
2564 **----- / ) --------------------------------------------------------**
2565 ** ( * ( statement.h **
2566 **---- \#/ --------------------------------------------------------**
2567- ** .-"#'-. First version: september 8th 2003 **
2568+ ** .-"#'-. First version: july 9th 2012 **
2569 **--- |"-.-"| -------------------------------------------------------**
2570 | |
2571 | |
2572@@ -33,68 +33,38 @@
2573 * *
2574 ******************************************************************************/
2575
2576+/*
2577+ * author Joel Poudroux
2578+ */
2579
2580 #ifndef CANDL_STATEMENT_H
2581-# define CANDL_STATEMENT_H
2582-
2583-# include <stdio.h>
2584-# include <candl/matrix.h>
2585+#define CANDL_STATEMENT_H
2586
2587 # if defined(__cplusplus)
2588 extern "C"
2589 {
2590 # endif
2591
2592+struct osl_scop;
2593+struct osl_statement;
2594
2595-/**
2596- * CandlStatement structure:
2597- * this structure contains all the informations about a program statement.
2598- */
2599-struct candlstatement
2600-{ int label; /**< Statement number (it must be the array
2601- * index of this statement in the "statement"
2602- * field of the CandlProgram structure).
2603- */
2604- int type; /**< Statement type. */
2605- int depth; /**< Nesting level (nb of surrounding loops).*/
2606- int * index; /**< Iteration domain's iterator labels. */
2607- CandlMatrix * domain; /**< Iteration domain. */
2608- CandlMatrix * written; /**< Array of written data. */
2609- CandlMatrix * read; /**< Array of read data. */
2610- void* ref; /**< Reference to another structure
2611- describing the same statement. */
2612+struct candl_statement_usr {
2613+ int label; /**< Statement label = 'n'th statement */
2614+ int depth;
2615+ int type;
2616+ int *index; /**< Loops label name */
2617+ void *usr_backup; /**< If there is already a usr field, it will be saved */
2618 };
2619-typedef struct candlstatement CandlStatement;
2620-
2621
2622-/******************************************************************************
2623- * Structure display function *
2624- ******************************************************************************/
2625-void candl_statement_print_structure(FILE *, CandlStatement *, int);
2626-void candl_statement_print(FILE *, CandlStatement *);
2627-
2628-
2629-/******************************************************************************
2630- * Memory deallocation function *
2631- ******************************************************************************/
2632-void candl_statement_free(CandlStatement *);
2633-
2634-
2635-/******************************************************************************
2636- * Reading functions *
2637- ******************************************************************************/
2638-CandlStatement * candl_statement_read(FILE *, int, int);
2639-
2640-
2641-/******************************************************************************
2642- * Processing functions *
2643- ******************************************************************************/
2644-CandlStatement * candl_statement_malloc();
2645-int candl_statement_commute(CandlStatement *, CandlStatement *);
2646+typedef struct candl_statement_usr candl_statement_usr_t;
2647+typedef struct candl_statement_usr* candl_statement_usr_p;
2648
2649+void candl_statement_usr_init_all(struct osl_scop*);
2650+void candl_statement_usr_cleanup(struct osl_statement*);
2651
2652 # if defined(__cplusplus)
2653 }
2654 # endif
2655-#endif /* define CANDL_STATEMENT_H */
2656
2657+
2658+#endif
2659diff --git a/include/candl/util.h b/include/candl/util.h
2660new file mode 100644
2661index 0000000..c20f09b
2662--- /dev/null
2663+++ b/include/candl/util.h
2664@@ -0,0 +1,61 @@
2665+
2666+ /**------ ( ----------------------------------------------------------**
2667+ ** )\ CAnDL **
2668+ **----- / ) --------------------------------------------------------**
2669+ ** ( * ( util.h **
2670+ **---- \#/ --------------------------------------------------------**
2671+ ** .-"#'-. First version: june 7th 2012 **
2672+ **--- |"-.-"| -------------------------------------------------------**
2673+ | |
2674+ | |
2675+ ******** | | *************************************************************
2676+ * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
2677+ ******************************************************************************
2678+ * *
2679+ * Copyright (C) 2003-2008 Cedric Bastoul *
2680+ * *
2681+ * This is free software; you can redistribute it and/or modify it under the *
2682+ * terms of the GNU General Public License as published by the Free Software *
2683+ * Foundation; either version 2 of the License, or (at your option) any later *
2684+ * version. *
2685+ * *
2686+ * This software is distributed in the hope that it will be useful, but *
2687+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
2688+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
2689+ * for more details. *
2690+ * *
2691+ * You should have received a copy of the GNU General Public License along *
2692+ * with software; if not, write to the Free Software Foundation, Inc., *
2693+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
2694+ * *
2695+ * CAnDL, the Chunky Dependence Analyzer *
2696+ * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
2697+ * *
2698+ ******************************************************************************/
2699+
2700+/*
2701+ * author Joel Poudroux
2702+ */
2703+
2704+#ifndef CANDL_UTIL_H
2705+#define CANDL_UTIL_H
2706+
2707+# if defined(__cplusplus)
2708+extern "C"
2709+ {
2710+# endif
2711+
2712+struct osl_scop;
2713+struct osl_relation;
2714+struct osl_statement;
2715+
2716+int candl_util_relation_get_line(struct osl_relation*, int);
2717+int candl_util_statement_commute(struct osl_statement*, struct osl_statement*);
2718+int candl_util_check_scop(struct osl_scop*, struct osl_scop*);
2719+int candl_util_check_scop_list(struct osl_scop*, struct osl_scop*);
2720+
2721+# if defined(__cplusplus)
2722+ }
2723+# endif
2724+
2725+#endif
2726diff --git a/include/candl/violation.h b/include/candl/violation.h
2727index da09565..f395b63 100644
2728--- a/include/candl/violation.h
2729+++ b/include/candl/violation.h
2730@@ -38,52 +38,92 @@
2731 # define CANDL_VIOLATION_H
2732
2733 # include <stdio.h>
2734-# include <candl/dependence.h>
2735-# include <candl/matrix.h>
2736+# include <candl/options.h>
2737
2738 # if defined(__cplusplus)
2739 extern "C"
2740 {
2741 # endif
2742
2743+struct osl_scop;
2744+struct osl_dependence;
2745+struct osl_relation;
2746
2747 /**
2748 * CandlViolation structure:
2749 * this structure contains all informations about a data dependence violation.
2750- */
2751-struct candlviolation
2752-{ CandlDependence * dependence; /**< Pointer to violated dependence. */
2753- int dimension; /**< Violation dimension. */
2754- CandlMatrix * domain; /**< Violation polyhedron. */
2755- struct candlviolation * next; /**< Pointer to next violation. */
2756+ *
2757+
2758+ Violation domain structure
2759+ ________________________________________________________________________________________________
2760+ / source (output) | target (input) | local dims \
2761+ __ |_______________________|_______________________|___________________________________________________|_____________
2762+ / eq |output |output |output |output |output |output |ld dom |ld acc |ld scatt |ld dom |ld acc |ld scatt | | \
2763+ | in |domain |access |scatt |domain |access |scatt |source |source |source |target |target |target |parameters | 1 |
2764+ _____________________|____|_______|_______|_______|_______|_______|_______|_______|_______|_________|_______|_______|_________|___________|___|
2765+ |Domain source | X | X : : | : : | X : : | : : | X | X |
2766+ |________________|____|_______:_______:_______|_______:_______:_______|_______:_______:_________|_______:_______:_________|___________|___|
2767+ |Domain target | X | : : | X : : | : : | X : : | X | X |
2768+ |________________|____|_______:_______:_______|_______:_______:_______|_______:_______:_________|_______:_______:_________|___________|___|
2769+ Dependence |Access source | X | X : X : | : : | : X : | : : | X | X |
2770+ system |________________|____|_______:_______:_______|_______:_______:_______|_______:_______:_________|_______:_______:_________|___________|___|
2771+ |Access target | X | : : | X : X : | : : | : X : | X | X |
2772+ |________________|____|_______:_______:_______|_______:_______:_______|_______:_______:_________|_______:_______:_________|___________|___|
2773+ |Access equality | | : Id : | : -Id : | : : | : : | | |
2774+ |________________|____|_______:_______:_______|_______:_______:_______|_______:_______:_________|_______:_______:_________|___________|___| | 0 : 0..depth-1
2775+ |Precedence | X | Id : : | -Id : : | : : | : : | | X | <--| 0|-1 : depth
2776+ ===============================================================================================================================================
2777+ |Scattering | | : : | : : | : : | : : | | |
2778+ |source | X | X : : X | : : | : : X | : : | X | X |
2779+ |________________|____|_______:_______:_______|_______:_______:_______|_______:_______:_________|_______:_______:_________|___________|___|
2780+ |Scattering | | : : | : : | : : | : : | | |
2781+ |target | X | : : | X : : X | : : | : : X | X | X |
2782+ |________________|____|_______:_______:_______|_______:_______:_______|_______:_______:_________|_______:_______:_________|___________|___|
2783+ |Equality at | | : : | : : | : : | : : | | |
2784+ |1 ... dim_1 | | : : Id | : : -Id | : : | : : | | |
2785+ |________________|____|_______:_______:_______|_______:_______:_______|_______:_______:_________|_______:_______:_________|___________|___|
2786+ at |Scat source > | | : : | : : | : : | : : | | |
2787+ dim |Scat target | 1 | : : 1 | : : -1 | : : | : : | |-1 |
2788+ \________________|____|_______:_______:_______|_______:_______:_______|_______:_______:_________|_______:_______:_________|___________|___/
2789+
2790+ (1) (2) (3) (4)
2791+*/
2792+
2793+struct candl_violation {
2794+ struct osl_dependence* dependence; /**< Pointer to violated dependence. */
2795+ int dimension; /**< Violation dimension. */
2796+ struct osl_relation* domain; /**< Violation polyhedron. */
2797+ struct candl_violation* next; /**< Pointer to next violation. */
2798+
2799+ int source_nb_output_dims_scattering; // (1)
2800+ int target_nb_output_dims_scattering; // (2)
2801+ int source_nb_local_dims_scattering; // (3)
2802+ int target_nb_local_dims_scattering; // (4)
2803 };
2804-typedef struct candlviolation CandlViolation;
2805-
2806+typedef struct candl_violation candl_violation_t;
2807+typedef struct candl_violation* candl_violation_p;
2808
2809 /******************************************************************************
2810 * Structure display function *
2811 ******************************************************************************/
2812-void candl_violation_print_structure(FILE *, CandlViolation *, int);
2813-void candl_violation_print(FILE *, CandlViolation *);
2814-void candl_violation_pprint(FILE *, CandlViolation *);
2815-void candl_violation_view(CandlViolation *);
2816-
2817+void candl_violation_idump(FILE*, candl_violation_p, int);
2818+void candl_violation_dump(FILE*, candl_violation_p);
2819+void candl_violation_pprint(FILE*, candl_violation_p);
2820+void candl_violation_view(candl_violation_p);
2821
2822 /******************************************************************************
2823 * Memory deallocation function *
2824 ******************************************************************************/
2825-void candl_violation_free(CandlViolation *);
2826-
2827+void candl_violation_free(candl_violation_p);
2828
2829 /******************************************************************************
2830 * Processing functions *
2831 ******************************************************************************/
2832-CandlViolation * candl_violation_malloc();
2833-void candl_violation_add(CandlViolation **, CandlViolation **,
2834- CandlViolation *);
2835-CandlViolation * candl_violation(CandlProgram *, CandlDependence *,
2836- CandlOptions *);
2837-
2838+candl_violation_p candl_violation_malloc();
2839+void candl_violation_add(candl_violation_p*, candl_violation_p*,
2840+ candl_violation_p);
2841+candl_violation_p candl_violation(struct osl_scop*, struct osl_dependence*,
2842+ struct osl_scop*, candl_options_p);
2843
2844 # if defined(__cplusplus)
2845 }
2846diff --git a/m4/ax_cc_maxopt.m4 b/m4/ax_cc_maxopt.m4
2847new file mode 100644
2848index 0000000..da415be
2849--- /dev/null
2850+++ b/m4/ax_cc_maxopt.m4
2851@@ -0,0 +1,178 @@
2852+# ===========================================================================
2853+# http://www.nongnu.org/autoconf-archive/ax_cc_maxopt.html
2854+# ===========================================================================
2855+#
2856+# SYNOPSIS
2857+#
2858+# AX_CC_MAXOPT
2859+#
2860+# DESCRIPTION
2861+#
2862+# Try to turn on "good" C optimization flags for various compilers and
2863+# architectures, for some definition of "good". (In our case, good for
2864+# FFTW and hopefully for other scientific codes. Modify as needed.)
2865+#
2866+# The user can override the flags by setting the CFLAGS environment
2867+# variable. The user can also specify --enable-portable-binary in order to
2868+# disable any optimization flags that might result in a binary that only
2869+# runs on the host architecture.
2870+#
2871+# Note also that the flags assume that ANSI C aliasing rules are followed
2872+# by the code (e.g. for gcc's -fstrict-aliasing), and that floating-point
2873+# computations can be re-ordered as needed.
2874+#
2875+# Requires macros: AX_CHECK_COMPILER_FLAGS, AX_COMPILER_VENDOR,
2876+# AX_GCC_ARCHFLAG, AX_GCC_X86_CPUID.
2877+#
2878+# LICENSE
2879+#
2880+# Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
2881+# Copyright (c) 2008 Matteo Frigo
2882+#
2883+# This program is free software: you can redistribute it and/or modify it
2884+# under the terms of the GNU General Public License as published by the
2885+# Free Software Foundation, either version 3 of the License, or (at your
2886+# option) any later version.
2887+#
2888+# This program is distributed in the hope that it will be useful, but
2889+# WITHOUT ANY WARRANTY; without even the implied warranty of
2890+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
2891+# Public License for more details.
2892+#
2893+# You should have received a copy of the GNU General Public License along
2894+# with this program. If not, see <http://www.gnu.org/licenses/>.
2895+#
2896+# As a special exception, the respective Autoconf Macro's copyright owner
2897+# gives unlimited permission to copy, distribute and modify the configure
2898+# scripts that are the output of Autoconf when processing the Macro. You
2899+# need not follow the terms of the GNU General Public License when using
2900+# or distributing such scripts, even though portions of the text of the
2901+# Macro appear in them. The GNU General Public License (GPL) does govern
2902+# all other use of the material that constitutes the Autoconf Macro.
2903+#
2904+# This special exception to the GPL applies to versions of the Autoconf
2905+# Macro released by the Autoconf Archive. When you make and distribute a
2906+# modified version of the Autoconf Macro, you may extend this special
2907+# exception to the GPL to apply to your modified version as well.
2908+
2909+AC_DEFUN([AX_CC_MAXOPT],
2910+[
2911+AC_REQUIRE([AC_PROG_CC])
2912+AC_REQUIRE([AX_COMPILER_VENDOR])
2913+AC_REQUIRE([AC_CANONICAL_HOST])
2914+
2915+AC_ARG_ENABLE(portable-binary, [AC_HELP_STRING([--enable-portable-binary], [disable compiler optimizations that would produce unportable binaries])],
2916+ acx_maxopt_portable=$withval, acx_maxopt_portable=no)
2917+
2918+# Try to determine "good" native compiler flags if none specified via CFLAGS
2919+if test "$ac_test_CFLAGS" != "set"; then
2920+ CFLAGS=""
2921+ case $ax_cv_c_compiler_vendor in
2922+ dec) CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host"
2923+ if test "x$acx_maxopt_portable" = xno; then
2924+ CFLAGS="$CFLAGS -arch host"
2925+ fi;;
2926+
2927+ sun) CFLAGS="-native -fast -xO5 -dalign"
2928+ if test "x$acx_maxopt_portable" = xyes; then
2929+ CFLAGS="$CFLAGS -xarch=generic"
2930+ fi;;
2931+
2932+ hp) CFLAGS="+Oall +Optrs_ansi +DSnative"
2933+ if test "x$acx_maxopt_portable" = xyes; then
2934+ CFLAGS="$CFLAGS +DAportable"
2935+ fi;;
2936+
2937+ ibm) if test "x$acx_maxopt_portable" = xno; then
2938+ xlc_opt="-qarch=auto -qtune=auto"
2939+ else
2940+ xlc_opt="-qtune=auto"
2941+ fi
2942+ AX_CHECK_COMPILER_FLAGS($xlc_opt,
2943+ CFLAGS="-O3 -qansialias -w $xlc_opt",
2944+ [CFLAGS="-O3 -qansialias -w"
2945+ echo "******************************************************"
2946+ echo "* You seem to have the IBM C compiler. It is *"
2947+ echo "* recommended for best performance that you use: *"
2948+ echo "* *"
2949+ echo "* CFLAGS=-O3 -qarch=xxx -qtune=xxx -qansialias -w *"
2950+ echo "* ^^^ ^^^ *"
2951+ echo "* where xxx is pwr2, pwr3, 604, or whatever kind of *"
2952+ echo "* CPU you have. (Set the CFLAGS environment var. *"
2953+ echo "* and re-run configure.) For more info, man cc. *"
2954+ echo "******************************************************"])
2955+ ;;
2956+
2957+ intel) CFLAGS="-O3 -ansi_alias"
2958+ if test "x$acx_maxopt_portable" = xno; then
2959+ icc_archflag=unknown
2960+ icc_flags=""
2961+ case $host_cpu in
2962+ i686*|x86_64*)
2963+ # icc accepts gcc assembly syntax, so these should work:
2964+ AX_GCC_X86_CPUID(0)
2965+ AX_GCC_X86_CPUID(1)
2966+ case $ax_cv_gcc_x86_cpuid_0 in # see AX_GCC_ARCHFLAG
2967+ *:756e6547:*:*) # Intel
2968+ case $ax_cv_gcc_x86_cpuid_1 in
2969+ *6a?:*[[234]]:*:*|*6[[789b]]?:*:*:*) icc_flags="-xK";;
2970+ *f3[[347]]:*:*:*|*f4[1347]:*:*:*) icc_flags="-xP -xN -xW -xK";;
2971+ *f??:*:*:*) icc_flags="-xN -xW -xK";;
2972+ esac ;;
2973+ esac ;;
2974+ esac
2975+ if test "x$icc_flags" != x; then
2976+ for flag in $icc_flags; do
2977+ AX_CHECK_COMPILER_FLAGS($flag, [icc_archflag=$flag; break])
2978+ done
2979+ fi
2980+ AC_MSG_CHECKING([for icc architecture flag])
2981+ AC_MSG_RESULT($icc_archflag)
2982+ if test "x$icc_archflag" != xunknown; then
2983+ CFLAGS="$CFLAGS $icc_archflag"
2984+ fi
2985+ fi
2986+ ;;
2987+
2988+ gnu)
2989+ # default optimization flags for gcc on all systems
2990+ CFLAGS="-O3 -fomit-frame-pointer"
2991+
2992+ # -malign-double for x86 systems
2993+ AX_CHECK_COMPILER_FLAGS(-malign-double, CFLAGS="$CFLAGS -malign-double")
2994+
2995+ # -fstrict-aliasing for gcc-2.95+
2996+ AX_CHECK_COMPILER_FLAGS(-fstrict-aliasing,
2997+ CFLAGS="$CFLAGS -fstrict-aliasing")
2998+
2999+ # note that we enable "unsafe" fp optimization with other compilers, too
3000+ AX_CHECK_COMPILER_FLAGS(-ffast-math, CFLAGS="$CFLAGS -ffast-math")
3001+
3002+ AX_GCC_ARCHFLAG($acx_maxopt_portable)
3003+ ;;
3004+ esac
3005+
3006+ if test -z "$CFLAGS"; then
3007+ echo ""
3008+ echo "********************************************************"
3009+ echo "* WARNING: Don't know the best CFLAGS for this system *"
3010+ echo "* Use ./configure CFLAGS=... to specify your own flags *"
3011+ echo "* (otherwise, a default of CFLAGS=-O3 will be used) *"
3012+ echo "********************************************************"
3013+ echo ""
3014+ CFLAGS="-O3"
3015+ fi
3016+
3017+ AX_CHECK_COMPILER_FLAGS($CFLAGS, [], [
3018+ echo ""
3019+ echo "********************************************************"
3020+ echo "* WARNING: The guessed CFLAGS don't seem to work with *"
3021+ echo "* your compiler. *"
3022+ echo "* Use ./configure CFLAGS=... to specify your own flags *"
3023+ echo "********************************************************"
3024+ echo ""
3025+ CFLAGS=""
3026+ ])
3027+
3028+fi
3029+])
3030diff --git a/m4/ax_cflags_warn_all.m4 b/m4/ax_cflags_warn_all.m4
3031new file mode 100644
3032index 0000000..026c6e9
3033--- /dev/null
3034+++ b/m4/ax_cflags_warn_all.m4
3035@@ -0,0 +1,149 @@
3036+# ===========================================================================
3037+# http://www.nongnu.org/autoconf-archive/ax_cflags_warn_all.html
3038+# ===========================================================================
3039+#
3040+# SYNOPSIS
3041+#
3042+# AX_CFLAGS_WARN_ALL [(shellvar [,default, [A/NA]])]
3043+#
3044+# DESCRIPTION
3045+#
3046+# Try to find a compiler option that enables most reasonable warnings.
3047+#
3048+# For the GNU CC compiler it will be -Wall (and -ansi -pedantic) The
3049+# result is added to the shellvar being CFLAGS by default.
3050+#
3051+# Currently this macro knows about GCC, Solaris C compiler, Digital Unix C
3052+# compiler, C for AIX Compiler, HP-UX C compiler, IRIX C compiler, NEC
3053+# SX-5 (Super-UX 10) C compiler, and Cray J90 (Unicos 10.0.0.8) C
3054+# compiler.
3055+#
3056+# - $1 shell-variable-to-add-to : CFLAGS
3057+# - $2 add-value-if-not-found : nothing
3058+# - $3 action-if-found : add value to shellvariable
3059+# - $4 action-if-not-found : nothing
3060+#
3061+# LICENSE
3062+#
3063+# Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
3064+#
3065+# This program is free software; you can redistribute it and/or modify it
3066+# under the terms of the GNU General Public License as published by the
3067+# Free Software Foundation; either version 2 of the License, or (at your
3068+# option) any later version.
3069+#
3070+# This program is distributed in the hope that it will be useful, but
3071+# WITHOUT ANY WARRANTY; without even the implied warranty of
3072+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
3073+# Public License for more details.
3074+#
3075+# You should have received a copy of the GNU General Public License along
3076+# with this program. If not, see <http://www.gnu.org/licenses/>.
3077+#
3078+# As a special exception, the respective Autoconf Macro's copyright owner
3079+# gives unlimited permission to copy, distribute and modify the configure
3080+# scripts that are the output of Autoconf when processing the Macro. You
3081+# need not follow the terms of the GNU General Public License when using
3082+# or distributing such scripts, even though portions of the text of the
3083+# Macro appear in them. The GNU General Public License (GPL) does govern
3084+# all other use of the material that constitutes the Autoconf Macro.
3085+#
3086+# This special exception to the GPL applies to versions of the Autoconf
3087+# Macro released by the Autoconf Archive. When you make and distribute a
3088+# modified version of the Autoconf Macro, you may extend this special
3089+# exception to the GPL to apply to your modified version as well.
3090+
3091+AC_DEFUN([AX_CFLAGS_WARN_ALL],[dnl
3092+AS_VAR_PUSHDEF([FLAGS],[CFLAGS])dnl
3093+AS_VAR_PUSHDEF([VAR],[ac_cv_cflags_warn_all])dnl
3094+AC_CACHE_CHECK([m4_ifval($1,$1,FLAGS) for maximum warnings],
3095+VAR,[VAR="no, unknown"
3096+ AC_LANG_SAVE
3097+ AC_LANG_C
3098+ ac_save_[]FLAGS="$[]FLAGS"
3099+for ac_arg dnl
3100+in "-pedantic % -Wall" dnl GCC
3101+ "-xstrconst % -v" dnl Solaris C
3102+ "-std1 % -verbose -w0 -warnprotos" dnl Digital Unix
3103+ "-qlanglvl=ansi % -qsrcmsg -qinfo=all:noppt:noppc:noobs:nocnd" dnl AIX
3104+ "-ansi -ansiE % -fullwarn" dnl IRIX
3105+ "+ESlit % +w1" dnl HP-UX C
3106+ "-Xc % -pvctl[,]fullmsg" dnl NEC SX-5 (Super-UX 10)
3107+ "-h conform % -h msglevel 2" dnl Cray C (Unicos)
3108+ #
3109+do FLAGS="$ac_save_[]FLAGS "`echo $ac_arg | sed -e 's,%%.*,,' -e 's,%,,'`
3110+ AC_TRY_COMPILE([],[return 0;],
3111+ [VAR=`echo $ac_arg | sed -e 's,.*% *,,'` ; break])
3112+done
3113+ FLAGS="$ac_save_[]FLAGS"
3114+ AC_LANG_RESTORE
3115+])
3116+case ".$VAR" in
3117+ .ok|.ok,*) m4_ifvaln($3,$3) ;;
3118+ .|.no|.no,*) m4_ifvaln($4,$4,[m4_ifval($2,[
3119+ AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])
3120+ m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])]) ;;
3121+ *) m4_ifvaln($3,$3,[
3122+ if echo " $[]m4_ifval($1,$1,FLAGS) " | grep " $VAR " 2>&1 >/dev/null
3123+ then AC_RUN_LOG([: m4_ifval($1,$1,FLAGS) does contain $VAR])
3124+ else AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"])
3125+ m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"
3126+ fi ]) ;;
3127+esac
3128+AS_VAR_POPDEF([VAR])dnl
3129+AS_VAR_POPDEF([FLAGS])dnl
3130+])
3131+
3132+dnl the only difference - the LANG selection... and the default FLAGS
3133+
3134+AC_DEFUN([AX_CXXFLAGS_WARN_ALL],[dnl
3135+AS_VAR_PUSHDEF([FLAGS],[CXXFLAGS])dnl
3136+AS_VAR_PUSHDEF([VAR],[ax_cv_cxxflags_warn_all])dnl
3137+AC_CACHE_CHECK([m4_ifval($1,$1,FLAGS) for maximum warnings],
3138+VAR,[VAR="no, unknown"
3139+ AC_LANG_SAVE
3140+ AC_LANG_CPLUSPLUS
3141+ ac_save_[]FLAGS="$[]FLAGS"
3142+for ac_arg dnl
3143+in "-pedantic % -Wall" dnl GCC
3144+ "-xstrconst % -v" dnl Solaris C
3145+ "-std1 % -verbose -w0 -warnprotos" dnl Digital Unix
3146+ "-qlanglvl=ansi % -qsrcmsg -qinfo=all:noppt:noppc:noobs:nocnd" dnl AIX
3147+ "-ansi -ansiE % -fullwarn" dnl IRIX
3148+ "+ESlit % +w1" dnl HP-UX C
3149+ "-Xc % -pvctl[,]fullmsg" dnl NEC SX-5 (Super-UX 10)
3150+ "-h conform % -h msglevel 2" dnl Cray C (Unicos)
3151+ #
3152+do FLAGS="$ac_save_[]FLAGS "`echo $ac_arg | sed -e 's,%%.*,,' -e 's,%,,'`
3153+ AC_TRY_COMPILE([],[return 0;],
3154+ [VAR=`echo $ac_arg | sed -e 's,.*% *,,'` ; break])
3155+done
3156+ FLAGS="$ac_save_[]FLAGS"
3157+ AC_LANG_RESTORE
3158+])
3159+case ".$VAR" in
3160+ .ok|.ok,*) m4_ifvaln($3,$3) ;;
3161+ .|.no|.no,*) m4_ifvaln($4,$4,[m4_ifval($2,[
3162+ AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])
3163+ m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $2"])]) ;;
3164+ *) m4_ifvaln($3,$3,[
3165+ if echo " $[]m4_ifval($1,$1,FLAGS) " | grep " $VAR " 2>&1 >/dev/null
3166+ then AC_RUN_LOG([: m4_ifval($1,$1,FLAGS) does contain $VAR])
3167+ else AC_RUN_LOG([: m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"])
3168+ m4_ifval($1,$1,FLAGS)="$m4_ifval($1,$1,FLAGS) $VAR"
3169+ fi ]) ;;
3170+esac
3171+AS_VAR_POPDEF([VAR])dnl
3172+AS_VAR_POPDEF([FLAGS])dnl
3173+])
3174+
3175+dnl implementation tactics:
3176+dnl the for-argument contains a list of options. The first part of
3177+dnl these does only exist to detect the compiler - usually it is
3178+dnl a global option to enable -ansi or -extrawarnings. All other
3179+dnl compilers will fail about it. That was needed since a lot of
3180+dnl compilers will give false positives for some option-syntax
3181+dnl like -Woption or -Xoption as they think of it is a pass-through
3182+dnl to later compile stages or something. The "%" is used as a
3183+dnl delimimiter. A non-option comment can be given after "%%" marks
3184+dnl which will be shown but not added to the respective C/CXXFLAGS.
3185diff --git a/m4/ax_check_compiler_flags.m4 b/m4/ax_check_compiler_flags.m4
3186new file mode 100644
3187index 0000000..7da8324
3188--- /dev/null
3189+++ b/m4/ax_check_compiler_flags.m4
3190@@ -0,0 +1,74 @@
3191+# ===========================================================================
3192+# http://www.nongnu.org/autoconf-archive/ax_check_compiler_flags.html
3193+# ===========================================================================
3194+#
3195+# SYNOPSIS
3196+#
3197+# AX_CHECK_COMPILER_FLAGS(FLAGS, [ACTION-SUCCESS], [ACTION-FAILURE])
3198+#
3199+# DESCRIPTION
3200+#
3201+# Check whether the given compiler FLAGS work with the current language's
3202+# compiler, or whether they give an error. (Warnings, however, are
3203+# ignored.)
3204+#
3205+# ACTION-SUCCESS/ACTION-FAILURE are shell commands to execute on
3206+# success/failure.
3207+#
3208+# LICENSE
3209+#
3210+# Copyright (c) 2009 Steven G. Johnson <stevenj@alum.mit.edu>
3211+# Copyright (c) 2009 Matteo Frigo
3212+#
3213+# This program is free software: you can redistribute it and/or modify it
3214+# under the terms of the GNU General Public License as published by the
3215+# Free Software Foundation, either version 3 of the License, or (at your
3216+# option) any later version.
3217+#
3218+# This program is distributed in the hope that it will be useful, but
3219+# WITHOUT ANY WARRANTY; without even the implied warranty of
3220+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
3221+# Public License for more details.
3222+#
3223+# You should have received a copy of the GNU General Public License along
3224+# with this program. If not, see <http://www.gnu.org/licenses/>.
3225+#
3226+# As a special exception, the respective Autoconf Macro's copyright owner
3227+# gives unlimited permission to copy, distribute and modify the configure
3228+# scripts that are the output of Autoconf when processing the Macro. You
3229+# need not follow the terms of the GNU General Public License when using
3230+# or distributing such scripts, even though portions of the text of the
3231+# Macro appear in them. The GNU General Public License (GPL) does govern
3232+# all other use of the material that constitutes the Autoconf Macro.
3233+#
3234+# This special exception to the GPL applies to versions of the Autoconf
3235+# Macro released by the Autoconf Archive. When you make and distribute a
3236+# modified version of the Autoconf Macro, you may extend this special
3237+# exception to the GPL to apply to your modified version as well.
3238+
3239+AC_DEFUN([AX_CHECK_COMPILER_FLAGS],
3240+[AC_PREREQ(2.59) dnl for _AC_LANG_PREFIX
3241+AC_MSG_CHECKING([whether _AC_LANG compiler accepts $1])
3242+dnl Some hackery here since AC_CACHE_VAL can't handle a non-literal varname:
3243+AS_LITERAL_IF([$1],
3244+ [AC_CACHE_VAL(AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_[$1]), [
3245+ ax_save_FLAGS=$[]_AC_LANG_PREFIX[]FLAGS
3246+ _AC_LANG_PREFIX[]FLAGS="$1"
3247+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
3248+ AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_[$1])=yes,
3249+ AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_[$1])=no)
3250+ _AC_LANG_PREFIX[]FLAGS=$ax_save_FLAGS])],
3251+ [ax_save_FLAGS=$[]_AC_LANG_PREFIX[]FLAGS
3252+ _AC_LANG_PREFIX[]FLAGS="$1"
3253+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
3254+ eval AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_[$1])=yes,
3255+ eval AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_[$1])=no)
3256+ _AC_LANG_PREFIX[]FLAGS=$ax_save_FLAGS])
3257+eval ax_check_compiler_flags=$AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_[$1])
3258+AC_MSG_RESULT($ax_check_compiler_flags)
3259+if test "x$ax_check_compiler_flags" = xyes; then
3260+ m4_default([$2], :)
3261+else
3262+ m4_default([$3], :)
3263+fi
3264+])dnl AX_CHECK_COMPILER_FLAGS
3265diff --git a/m4/ax_compiler_vendor.m4 b/m4/ax_compiler_vendor.m4
3266new file mode 100644
3267index 0000000..b074260
3268--- /dev/null
3269+++ b/m4/ax_compiler_vendor.m4
3270@@ -0,0 +1,61 @@
3271+# ===========================================================================
3272+# http://www.nongnu.org/autoconf-archive/ax_compiler_vendor.html
3273+# ===========================================================================
3274+#
3275+# SYNOPSIS
3276+#
3277+# AX_COMPILER_VENDOR
3278+#
3279+# DESCRIPTION
3280+#
3281+# Determine the vendor of the C/C++ compiler, e.g., gnu, intel, ibm, sun,
3282+# hp, borland, comeau, dec, cray, kai, lcc, metrowerks, sgi, microsoft,
3283+# watcom, etc. The vendor is returned in the cache variable
3284+# $ax_cv_c_compiler_vendor for C and $ax_cv_cxx_compiler_vendor for C++.
3285+#
3286+# LICENSE
3287+#
3288+# Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
3289+# Copyright (c) 2008 Matteo Frigo
3290+#
3291+# This program is free software: you can redistribute it and/or modify it
3292+# under the terms of the GNU General Public License as published by the
3293+# Free Software Foundation, either version 3 of the License, or (at your
3294+# option) any later version.
3295+#
3296+# This program is distributed in the hope that it will be useful, but
3297+# WITHOUT ANY WARRANTY; without even the implied warranty of
3298+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
3299+# Public License for more details.
3300+#
3301+# You should have received a copy of the GNU General Public License along
3302+# with this program. If not, see <http://www.gnu.org/licenses/>.
3303+#
3304+# As a special exception, the respective Autoconf Macro's copyright owner
3305+# gives unlimited permission to copy, distribute and modify the configure
3306+# scripts that are the output of Autoconf when processing the Macro. You
3307+# need not follow the terms of the GNU General Public License when using
3308+# or distributing such scripts, even though portions of the text of the
3309+# Macro appear in them. The GNU General Public License (GPL) does govern
3310+# all other use of the material that constitutes the Autoconf Macro.
3311+#
3312+# This special exception to the GPL applies to versions of the Autoconf
3313+# Macro released by the Autoconf Archive. When you make and distribute a
3314+# modified version of the Autoconf Macro, you may extend this special
3315+# exception to the GPL to apply to your modified version as well.
3316+
3317+AC_DEFUN([AX_COMPILER_VENDOR],
3318+[
3319+AC_CACHE_CHECK([for _AC_LANG compiler vendor], ax_cv_[]_AC_LANG_ABBREV[]_compiler_vendor,
3320+ [ax_cv_[]_AC_LANG_ABBREV[]_compiler_vendor=unknown
3321+ # note: don't check for gcc first since some other compilers define __GNUC__
3322+ for ventest in intel:__ICC,__ECC,__INTEL_COMPILER ibm:__xlc__,__xlC__,__IBMC__,__IBMCPP__ pathscale:__PATHCC__,__PATHSCALE__ gnu:__GNUC__ sun:__SUNPRO_C,__SUNPRO_CC hp:__HP_cc,__HP_aCC dec:__DECC,__DECCXX,__DECC_VER,__DECCXX_VER borland:__BORLANDC__,__TURBOC__ comeau:__COMO__ cray:_CRAYC kai:__KCC lcc:__LCC__ metrowerks:__MWERKS__ sgi:__sgi,sgi microsoft:_MSC_VER watcom:__WATCOMC__ portland:__PGI; do
3323+ vencpp="defined("`echo $ventest | cut -d: -f2 | sed 's/,/) || defined(/g'`")"
3324+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[
3325+#if !($vencpp)
3326+ thisisanerror;
3327+#endif
3328+])], [ax_cv_]_AC_LANG_ABBREV[_compiler_vendor=`echo $ventest | cut -d: -f1`; break])
3329+ done
3330+ ])
3331+])
3332diff --git a/m4/ax_gcc_archflag.m4 b/m4/ax_gcc_archflag.m4
3333new file mode 100644
3334index 0000000..dedeef4
3335--- /dev/null
3336+++ b/m4/ax_gcc_archflag.m4
3337@@ -0,0 +1,213 @@
3338+# ===========================================================================
3339+# http://www.nongnu.org/autoconf-archive/ax_gcc_archflag.html
3340+# ===========================================================================
3341+#
3342+# SYNOPSIS
3343+#
3344+# AX_GCC_ARCHFLAG([PORTABLE?], [ACTION-SUCCESS], [ACTION-FAILURE])
3345+#
3346+# DESCRIPTION
3347+#
3348+# This macro tries to guess the "native" arch corresponding to the target
3349+# architecture for use with gcc's -march=arch or -mtune=arch flags. If
3350+# found, the cache variable $ax_cv_gcc_archflag is set to this flag and
3351+# ACTION-SUCCESS is executed; otherwise $ax_cv_gcc_archflag is is set to
3352+# "unknown" and ACTION-FAILURE is executed. The default ACTION-SUCCESS is
3353+# to add $ax_cv_gcc_archflag to the end of $CFLAGS.
3354+#
3355+# PORTABLE? should be either [yes] (default) or [no]. In the former case,
3356+# the flag is set to -mtune (or equivalent) so that the architecture is
3357+# only used for tuning, but the instruction set used is still portable. In
3358+# the latter case, the flag is set to -march (or equivalent) so that
3359+# architecture-specific instructions are enabled.
3360+#
3361+# The user can specify --with-gcc-arch=<arch> in order to override the
3362+# macro's choice of architecture, or --without-gcc-arch to disable this.
3363+#
3364+# When cross-compiling, or if $CC is not gcc, then ACTION-FAILURE is
3365+# called unless the user specified --with-gcc-arch manually.
3366+#
3367+# Requires macros: AX_CHECK_COMPILER_FLAGS, AX_GCC_X86_CPUID
3368+#
3369+# (The main emphasis here is on recent CPUs, on the principle that doing
3370+# high-performance computing on old hardware is uncommon.)
3371+#
3372+# LICENSE
3373+#
3374+# Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
3375+# Copyright (c) 2008 Matteo Frigo
3376+#
3377+# This program is free software: you can redistribute it and/or modify it
3378+# under the terms of the GNU General Public License as published by the
3379+# Free Software Foundation, either version 3 of the License, or (at your
3380+# option) any later version.
3381+#
3382+# This program is distributed in the hope that it will be useful, but
3383+# WITHOUT ANY WARRANTY; without even the implied warranty of
3384+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
3385+# Public License for more details.
3386+#
3387+# You should have received a copy of the GNU General Public License along
3388+# with this program. If not, see <http://www.gnu.org/licenses/>.
3389+#
3390+# As a special exception, the respective Autoconf Macro's copyright owner
3391+# gives unlimited permission to copy, distribute and modify the configure
3392+# scripts that are the output of Autoconf when processing the Macro. You
3393+# need not follow the terms of the GNU General Public License when using
3394+# or distributing such scripts, even though portions of the text of the
3395+# Macro appear in them. The GNU General Public License (GPL) does govern
3396+# all other use of the material that constitutes the Autoconf Macro.
3397+#
3398+# This special exception to the GPL applies to versions of the Autoconf
3399+# Macro released by the Autoconf Archive. When you make and distribute a
3400+# modified version of the Autoconf Macro, you may extend this special
3401+# exception to the GPL to apply to your modified version as well.
3402+
3403+AC_DEFUN([AX_GCC_ARCHFLAG],
3404+[AC_REQUIRE([AC_PROG_CC])
3405+AC_REQUIRE([AC_CANONICAL_HOST])
3406+
3407+AC_ARG_WITH(gcc-arch, [AC_HELP_STRING([--with-gcc-arch=<arch>], [use architecture <arch> for gcc -march/-mtune, instead of guessing])],
3408+ ax_gcc_arch=$withval, ax_gcc_arch=yes)
3409+
3410+AC_MSG_CHECKING([for gcc architecture flag])
3411+AC_MSG_RESULT([])
3412+AC_CACHE_VAL(ax_cv_gcc_archflag,
3413+[
3414+ax_cv_gcc_archflag="unknown"
3415+
3416+if test "$GCC" = yes; then
3417+
3418+if test "x$ax_gcc_arch" = xyes; then
3419+ax_gcc_arch=""
3420+if test "$cross_compiling" = no; then
3421+case $host_cpu in
3422+ i[[3456]]86*|x86_64*) # use cpuid codes, in part from x86info-1.7 by D. Jones
3423+ AX_GCC_X86_CPUID(0)
3424+ AX_GCC_X86_CPUID(1)
3425+ case $ax_cv_gcc_x86_cpuid_0 in
3426+ *:756e6547:*:*) # Intel
3427+ case $ax_cv_gcc_x86_cpuid_1 in
3428+ *5[[48]]?:*:*:*) ax_gcc_arch="pentium-mmx pentium" ;;
3429+ *5??:*:*:*) ax_gcc_arch=pentium ;;
3430+ *6[[3456]]?:*:*:*) ax_gcc_arch="pentium2 pentiumpro" ;;
3431+ *6a?:*[[01]]:*:*) ax_gcc_arch="pentium2 pentiumpro" ;;
3432+ *6a?:*[[234]]:*:*) ax_gcc_arch="pentium3 pentiumpro" ;;
3433+ *6[[9d]]?:*:*:*) ax_gcc_arch="pentium-m pentium3 pentiumpro" ;;
3434+ *6[[78b]]?:*:*:*) ax_gcc_arch="pentium3 pentiumpro" ;;
3435+ *6??:*:*:*) ax_gcc_arch=pentiumpro ;;
3436+ *f3[[347]]:*:*:*|*f4[1347]:*:*:*)
3437+ case $host_cpu in
3438+ x86_64*) ax_gcc_arch="nocona pentium4 pentiumpro" ;;
3439+ *) ax_gcc_arch="prescott pentium4 pentiumpro" ;;
3440+ esac ;;
3441+ *f??:*:*:*) ax_gcc_arch="pentium4 pentiumpro";;
3442+ esac ;;
3443+ *:68747541:*:*) # AMD
3444+ case $ax_cv_gcc_x86_cpuid_1 in
3445+ *5[[67]]?:*:*:*) ax_gcc_arch=k6 ;;
3446+ *5[[8d]]?:*:*:*) ax_gcc_arch="k6-2 k6" ;;
3447+ *5[[9]]?:*:*:*) ax_gcc_arch="k6-3 k6" ;;
3448+ *60?:*:*:*) ax_gcc_arch=k7 ;;
3449+ *6[[12]]?:*:*:*) ax_gcc_arch="athlon k7" ;;
3450+ *6[[34]]?:*:*:*) ax_gcc_arch="athlon-tbird k7" ;;
3451+ *67?:*:*:*) ax_gcc_arch="athlon-4 athlon k7" ;;
3452+ *6[[68a]]?:*:*:*)
3453+ AX_GCC_X86_CPUID(0x80000006) # L2 cache size
3454+ case $ax_cv_gcc_x86_cpuid_0x80000006 in
3455+ *:*:*[[1-9a-f]]??????:*) # (L2 = ecx >> 16) >= 256
3456+ ax_gcc_arch="athlon-xp athlon-4 athlon k7" ;;
3457+ *) ax_gcc_arch="athlon-4 athlon k7" ;;
3458+ esac ;;
3459+ *f[[4cef8b]]?:*:*:*) ax_gcc_arch="athlon64 k8" ;;
3460+ *f5?:*:*:*) ax_gcc_arch="opteron k8" ;;
3461+ *f7?:*:*:*) ax_gcc_arch="athlon-fx opteron k8" ;;
3462+ *f??:*:*:*) ax_gcc_arch="k8" ;;
3463+ esac ;;
3464+ *:746e6543:*:*) # IDT
3465+ case $ax_cv_gcc_x86_cpuid_1 in
3466+ *54?:*:*:*) ax_gcc_arch=winchip-c6 ;;
3467+ *58?:*:*:*) ax_gcc_arch=winchip2 ;;
3468+ *6[[78]]?:*:*:*) ax_gcc_arch=c3 ;;
3469+ *69?:*:*:*) ax_gcc_arch="c3-2 c3" ;;
3470+ esac ;;
3471+ esac
3472+ if test x"$ax_gcc_arch" = x; then # fallback
3473+ case $host_cpu in
3474+ i586*) ax_gcc_arch=pentium ;;
3475+ i686*) ax_gcc_arch=pentiumpro ;;
3476+ esac
3477+ fi
3478+ ;;
3479+
3480+ sparc*)
3481+ AC_PATH_PROG([PRTDIAG], [prtdiag], [prtdiag], [$PATH:/usr/platform/`uname -i`/sbin/:/usr/platform/`uname -m`/sbin/])
3482+ cputype=`(((grep cpu /proc/cpuinfo | cut -d: -f2) ; ($PRTDIAG -v |grep -i sparc) ; grep -i cpu /var/run/dmesg.boot ) | head -n 1) 2> /dev/null`
3483+ cputype=`echo "$cputype" | tr -d ' -' |tr $as_cr_LETTERS $as_cr_letters`
3484+ case $cputype in
3485+ *ultrasparciv*) ax_gcc_arch="ultrasparc4 ultrasparc3 ultrasparc v9" ;;
3486+ *ultrasparciii*) ax_gcc_arch="ultrasparc3 ultrasparc v9" ;;
3487+ *ultrasparc*) ax_gcc_arch="ultrasparc v9" ;;
3488+ *supersparc*|*tms390z5[[05]]*) ax_gcc_arch="supersparc v8" ;;
3489+ *hypersparc*|*rt62[[056]]*) ax_gcc_arch="hypersparc v8" ;;
3490+ *cypress*) ax_gcc_arch=cypress ;;
3491+ esac ;;
3492+
3493+ alphaev5) ax_gcc_arch=ev5 ;;
3494+ alphaev56) ax_gcc_arch=ev56 ;;
3495+ alphapca56) ax_gcc_arch="pca56 ev56" ;;
3496+ alphapca57) ax_gcc_arch="pca57 pca56 ev56" ;;
3497+ alphaev6) ax_gcc_arch=ev6 ;;
3498+ alphaev67) ax_gcc_arch=ev67 ;;
3499+ alphaev68) ax_gcc_arch="ev68 ev67" ;;
3500+ alphaev69) ax_gcc_arch="ev69 ev68 ev67" ;;
3501+ alphaev7) ax_gcc_arch="ev7 ev69 ev68 ev67" ;;
3502+ alphaev79) ax_gcc_arch="ev79 ev7 ev69 ev68 ev67" ;;
3503+
3504+ powerpc*)
3505+ cputype=`((grep cpu /proc/cpuinfo | head -n 1 | cut -d: -f2 | cut -d, -f1 | sed 's/ //g') ; /usr/bin/machine ; /bin/machine; grep CPU /var/run/dmesg.boot | head -n 1 | cut -d" " -f2) 2> /dev/null`
3506+ cputype=`echo $cputype | sed -e 's/ppc//g;s/ *//g'`
3507+ case $cputype in
3508+ *750*) ax_gcc_arch="750 G3" ;;
3509+ *740[[0-9]]*) ax_gcc_arch="$cputype 7400 G4" ;;
3510+ *74[[4-5]][[0-9]]*) ax_gcc_arch="$cputype 7450 G4" ;;
3511+ *74[[0-9]][[0-9]]*) ax_gcc_arch="$cputype G4" ;;
3512+ *970*) ax_gcc_arch="970 G5 power4";;
3513+ *POWER4*|*power4*|*gq*) ax_gcc_arch="power4 970";;
3514+ *POWER5*|*power5*|*gr*|*gs*) ax_gcc_arch="power5 power4 970";;
3515+ 603ev|8240) ax_gcc_arch="$cputype 603e 603";;
3516+ *) ax_gcc_arch=$cputype ;;
3517+ esac
3518+ ax_gcc_arch="$ax_gcc_arch powerpc"
3519+ ;;
3520+esac
3521+fi # not cross-compiling
3522+fi # guess arch
3523+
3524+if test "x$ax_gcc_arch" != x -a "x$ax_gcc_arch" != xno; then
3525+for arch in $ax_gcc_arch; do
3526+ if test "x[]m4_default([$1],yes)" = xyes; then # if we require portable code
3527+ flags="-mtune=$arch"
3528+ # -mcpu=$arch and m$arch generate nonportable code on every arch except
3529+ # x86. And some other arches (e.g. Alpha) don't accept -mtune. Grrr.
3530+ case $host_cpu in i*86|x86_64*) flags="$flags -mcpu=$arch -m$arch";; esac
3531+ else
3532+ flags="-march=$arch -mcpu=$arch -m$arch"
3533+ fi
3534+ for flag in $flags; do
3535+ AX_CHECK_COMPILER_FLAGS($flag, [ax_cv_gcc_archflag=$flag; break])
3536+ done
3537+ test "x$ax_cv_gcc_archflag" = xunknown || break
3538+done
3539+fi
3540+
3541+fi # $GCC=yes
3542+])
3543+AC_MSG_CHECKING([for gcc architecture flag])
3544+AC_MSG_RESULT($ax_cv_gcc_archflag)
3545+if test "x$ax_cv_gcc_archflag" = xunknown; then
3546+ m4_default([$3],:)
3547+else
3548+ m4_default([$2], [CFLAGS="$CFLAGS $ax_cv_gcc_archflag"])
3549+fi
3550+])
3551diff --git a/m4/ax_gcc_x86_cpuid.m4 b/m4/ax_gcc_x86_cpuid.m4
3552new file mode 100644
3553index 0000000..5420b09
3554--- /dev/null
3555+++ b/m4/ax_gcc_x86_cpuid.m4
3556@@ -0,0 +1,77 @@
3557+# ===========================================================================
3558+# http://www.nongnu.org/autoconf-archive/ax_gcc_x86_cpuid.html
3559+# ===========================================================================
3560+#
3561+# SYNOPSIS
3562+#
3563+# AX_GCC_X86_CPUID(OP)
3564+#
3565+# DESCRIPTION
3566+#
3567+# On Pentium and later x86 processors, with gcc or a compiler that has a
3568+# compatible syntax for inline assembly instructions, run a small program
3569+# that executes the cpuid instruction with input OP. This can be used to
3570+# detect the CPU type.
3571+#
3572+# On output, the values of the eax, ebx, ecx, and edx registers are stored
3573+# as hexadecimal strings as "eax:ebx:ecx:edx" in the cache variable
3574+# ax_cv_gcc_x86_cpuid_OP.
3575+#
3576+# If the cpuid instruction fails (because you are running a
3577+# cross-compiler, or because you are not using gcc, or because you are on
3578+# a processor that doesn't have this instruction), ax_cv_gcc_x86_cpuid_OP
3579+# is set to the string "unknown".
3580+#
3581+# This macro mainly exists to be used in AX_GCC_ARCHFLAG.
3582+#
3583+# LICENSE
3584+#
3585+# Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
3586+# Copyright (c) 2008 Matteo Frigo
3587+#
3588+# This program is free software: you can redistribute it and/or modify it
3589+# under the terms of the GNU General Public License as published by the
3590+# Free Software Foundation, either version 3 of the License, or (at your
3591+# option) any later version.
3592+#
3593+# This program is distributed in the hope that it will be useful, but
3594+# WITHOUT ANY WARRANTY; without even the implied warranty of
3595+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
3596+# Public License for more details.
3597+#
3598+# You should have received a copy of the GNU General Public License along
3599+# with this program. If not, see <http://www.gnu.org/licenses/>.
3600+#
3601+# As a special exception, the respective Autoconf Macro's copyright owner
3602+# gives unlimited permission to copy, distribute and modify the configure
3603+# scripts that are the output of Autoconf when processing the Macro. You
3604+# need not follow the terms of the GNU General Public License when using
3605+# or distributing such scripts, even though portions of the text of the
3606+# Macro appear in them. The GNU General Public License (GPL) does govern
3607+# all other use of the material that constitutes the Autoconf Macro.
3608+#
3609+# This special exception to the GPL applies to versions of the Autoconf
3610+# Macro released by the Autoconf Archive. When you make and distribute a
3611+# modified version of the Autoconf Macro, you may extend this special
3612+# exception to the GPL to apply to your modified version as well.
3613+
3614+AC_DEFUN([AX_GCC_X86_CPUID],
3615+[AC_REQUIRE([AC_PROG_CC])
3616+AC_LANG_PUSH([C])
3617+AC_CACHE_CHECK(for x86 cpuid $1 output, ax_cv_gcc_x86_cpuid_$1,
3618+ [AC_RUN_IFELSE([AC_LANG_PROGRAM([#include <stdio.h>], [
3619+ int op = $1, eax, ebx, ecx, edx;
3620+ FILE *f;
3621+ __asm__("cpuid"
3622+ : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
3623+ : "a" (op));
3624+ f = fopen("conftest_cpuid", "w"); if (!f) return 1;
3625+ fprintf(f, "%x:%x:%x:%x\n", eax, ebx, ecx, edx);
3626+ fclose(f);
3627+ return 0;
3628+])],
3629+ [ax_cv_gcc_x86_cpuid_$1=`cat conftest_cpuid`; rm -f conftest_cpuid],
3630+ [ax_cv_gcc_x86_cpuid_$1=unknown; rm -f conftest_cpuid],
3631+ [ax_cv_gcc_x86_cpuid_$1=unknown])])
3632+AC_LANG_POP([C])
3633+])
3634diff --git a/m4/ax_submodule.m4 b/m4/ax_submodule.m4
3635new file mode 100644
3636index 0000000..57e3a56
3637--- /dev/null
3638+++ b/m4/ax_submodule.m4
3639@@ -0,0 +1,63 @@
3640+AC_DEFUN([AX_SUBMODULE],
3641+[
3642+
3643+AC_ARG_WITH($1,
3644+ [AS_HELP_STRING([--with-$1=$2],
3645+ [Which $1 to use])])
3646+case "system" in
3647+$2)
3648+ AC_ARG_WITH($1_prefix,
3649+ [AS_HELP_STRING([--with-$1-prefix=DIR],
3650+ [Prefix of $1 installation])])
3651+ AC_ARG_WITH($1_exec_prefix,
3652+ [AS_HELP_STRING([--with-$1-exec-prefix=DIR],
3653+ [Exec prefix of $1 installation])])
3654+esac
3655+case "build" in
3656+$2)
3657+ AC_ARG_WITH($1_builddir,
3658+ [AS_HELP_STRING([--with-$1-builddir=DIR],
3659+ [Location of $1 builddir])])
3660+esac
3661+if test "x$with_$1_prefix" != "x" -a "x$with_$1_exec_prefix" = "x"; then
3662+ with_$1_exec_prefix=$with_$1_prefix
3663+fi
3664+if test "x$with_$1_prefix" != "x" -o "x$with_$1_exec_prefix" != "x"; then
3665+ if test "x$with_$1" != "x" -a "x$with_$1" != "xsystem"; then
3666+ AC_MSG_ERROR([Setting $with_$1_prefix implies use of system $1])
3667+ fi
3668+ with_$1="system"
3669+fi
3670+if test "x$with_$1_builddir" != "x"; then
3671+ if test "x$with_$1" != "x" -a "x$with_$1" != "xbuild"; then
3672+ AC_MSG_ERROR([Setting $with_$1_builddir implies use of build $1])
3673+ fi
3674+ with_$1="build"
3675+ $1_srcdir=`echo @abs_srcdir@ | $with_$1_builddir/config.status --file=-`
3676+ AC_MSG_NOTICE($1 sources in $$1_srcdir)
3677+fi
3678+case "$with_$1" in
3679+$2)
3680+ ;;
3681+*)
3682+ if test -d $srcdir/.git -a \
3683+ -d $srcdir/$1 -a \
3684+ ! -d $srcdir/$1/.git; then
3685+ AC_MSG_WARN(
3686+[git repo detected, but submodule $1 not initialized])
3687+ AC_MSG_WARN([You may want to run])
3688+ AC_MSG_WARN([ git submodule init])
3689+ AC_MSG_WARN([ git submodule update])
3690+ AC_MSG_WARN([ sh autogen.sh])
3691+ fi
3692+ if test -f $srcdir/$1/configure -a "$3" != "no"; then
3693+ with_$1="bundled"
3694+ else
3695+ with_$1="$3"
3696+ fi
3697+ ;;
3698+esac
3699+AC_MSG_CHECKING([which $1 to use])
3700+AC_MSG_RESULT($with_$1)
3701+
3702+])
3703diff --git a/osl b/osl
3704new file mode 160000
3705index 0000000..46ef4ec
3706--- /dev/null
3707+++ b/osl
3708@@ -0,0 +1 @@
3709+Subproject commit 46ef4ec9917713d5d51dd45331c0e74870c5375d
3710diff --git a/piplib b/piplib
3711new file mode 160000
3712index 0000000..f2cfdd3
3713--- /dev/null
3714+++ b/piplib
3715@@ -0,0 +1 @@
3716+Subproject commit f2cfdd3f7a7c4c0c4f7408437205fa27bfb041ba
3717diff --git a/redo.sh b/redo.sh
3718new file mode 100755
3719index 0000000..a1cdb50
3720--- /dev/null
3721+++ b/redo.sh
3722@@ -0,0 +1,12 @@
3723+#!/bin/sh
3724+make maintainer-clean
3725+#./get_submodules.sh
3726+./autogen.sh
3727+./configure \
3728+ --prefix=$HOME/usr \
3729+ --with-osl=system \
3730+ --with-osl-prefix=$HOME/usr \
3731+ --with-piplib=system \
3732+ --with-piplib-prefix=$HOME/usr
3733+
3734+make
3735diff --git a/source/Makefile.am b/source/Makefile.am
3736deleted file mode 100644
3737index 3909be1..0000000
3738--- a/source/Makefile.am
3739+++ /dev/null
3740@@ -1,70 +0,0 @@
3741-#
3742-# /**-------------------------------------------------------------------**
3743-# ** CAnDL **
3744-# **-------------------------------------------------------------------**
3745-# ** Makefile.am **
3746-# **-------------------------------------------------------------------**
3747-# ** First version: september 8th 2003 **
3748-# **-------------------------------------------------------------------**/
3749-#
3750-#/*****************************************************************************
3751-# * CAnDL : the Chunky Analyser for Dependences in Loops (experimental) *
3752-# *****************************************************************************
3753-# * *
3754-# * Copyright (C) 2003-2008 Cedric Bastoul *
3755-# * *
3756-# * This is free software; you can redistribute it and/or modify it under the *
3757-# * terms of the GNU General Public License as published by the Free Software *
3758-# * Foundation; either version 2 of the License, or (at your option) any *
3759-# * later version. *
3760-# * *
3761-# * This software is distributed in the hope that it will be useful, but *
3762-# * WITHOUT ANY WARRANTY; without even the implied warranty of *
3763-# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General *
3764-# * Public License for more details. *
3765-# * *
3766-# * You should have received a copy of the GNU General Public License along *
3767-# * with software; if not, write to the Free Software Foundation, Inc., *
3768-# * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
3769-# * *
3770-# * CAnDL, the Chunky Dependence Analyser *
3771-# * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
3772-# * *
3773-# *****************************************************************************/
3774-
3775-
3776-#############################################################################
3777-SUBDIRS =
3778-
3779-#############################################################################
3780-MAINTAINERCLEANFILES = Makefile.in
3781-
3782-INCLUDES = -I$(top_builddir) -I$(top_srcdir) \
3783- -I$(top_builddir)/include \
3784- -I$(top_srcdir)/include
3785-
3786-#############################################################################
3787-
3788-lib_LTLIBRARIES = libcandl.la
3789-
3790-
3791-libcandl_la_SOURCES = \
3792- dependence.c \
3793- ddv.c \
3794- isl-wrapper.c \
3795- matrix.c \
3796- options.c \
3797- piplib-wrapper.c \
3798- program.c \
3799- pruning.c \
3800- statement.c \
3801- violation.c
3802-
3803-AM_CFLAGS = -Wall -fomit-frame-pointer -g
3804-
3805-
3806-bin_PROGRAMS = candl
3807-
3808-LDADD = libcandl.la
3809-
3810-candl_SOURCES = candl.c
3811diff --git a/source/candl.c b/source/candl.c
3812index 27e8ca4..df6bf18 100644
3813--- a/source/candl.c
3814+++ b/source/candl.c
3815@@ -6,8 +6,8 @@
3816 **---- \#/ --------------------------------------------------------**
3817 ** .-"#'-. First version: september 8th 2003 **
3818 **--- |"-.-"| -------------------------------------------------------**
3819- | |
3820- | |
3821+ | |
3822+ | |
3823 ******** | | *************************************************************
3824 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
3825 ******************************************************************************
3826@@ -33,98 +33,162 @@
3827 * *
3828 ******************************************************************************/
3829
3830-
3831 #include <stdlib.h>
3832 #include <stdio.h>
3833-#include <candl/candl.h>
3834+#include <osl/scop.h>
3835+#include <osl/macros.h>
3836+#include <osl/util.h>
3837+#include <osl/extensions/dependence.h>
3838+#include <candl/macros.h>
3839 #include <candl/dependence.h>
3840-#include <candl/program.h>
3841 #include <candl/violation.h>
3842 #include <candl/options.h>
3843+#include <candl/scop.h>
3844+#include <candl/util.h>
3845+#include <candl/piplib.h>
3846
3847
3848-int main(int argc, char * argv[])
3849-{
3850- CandlProgram * program = NULL;
3851- CandlOptions * options;
3852- CandlDependence * dependence;
3853- CandlViolation * violation = NULL;
3854- FILE * input, * output;
3855+int main(int argc, char * argv[]) {
3856+
3857+ osl_scop_p scop = NULL;
3858+ osl_scop_p orig_scop = NULL;
3859+ osl_dependence_p dep = NULL;
3860+ int num_scops = 0, i= 0;
3861+ candl_options_p options;
3862+ candl_violation_p *violations = NULL;
3863+ FILE *input, *output, *input_test;
3864+ int precision;
3865+ #if defined(CANDL_LINEAR_VALUE_IS_INT)
3866+ precision = OSL_PRECISION_SP;
3867+ #elif defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
3868+ precision = OSL_PRECISION_DP;
3869+ #elif defined(CANDL_LINEAR_VALUE_IS_MP)
3870+ precision = OSL_PRECISION_MP;
3871+ #endif
3872
3873 /* Options and input/output file setting. */
3874- candl_options_read(argc, argv, &input, &output, &options);
3875-
3876- /* Reading the program informations. */
3877-#ifdef CANDL_SUPPORTS_SCOPLIB
3878- if (options->readscop)
3879- {
3880- program = candl_program_read_scop(input);
3881- if (options->scoptocandl)
3882- {
3883- if (! options->readscop)
3884- program = candl_program_read_scop(input);
3885- candl_program_print_candl_file(output, program);
3886- candl_program_free(program);
3887- candl_options_free(options);
3888- return 0;
3889- }
3890- }
3891- else
3892-#endif
3893- program = candl_program_read(input);
3894-
3895+ candl_options_read(argc, argv, &input, &output, &input_test, &options);
3896+
3897+ /* Open the scop
3898+ * If there is no original scop (given with the -test), the input file
3899+ * is considered as the original scop
3900+ */
3901+ osl_interface_p registry = osl_interface_get_default_registry();
3902+ if (input_test != NULL) {
3903+ scop = osl_scop_pread(input, registry, precision);
3904+ orig_scop = osl_scop_pread(input_test, registry, precision);
3905+ } else {
3906+ orig_scop = osl_scop_pread(input, registry, precision);
3907+ }
3908+ osl_interface_free(registry);
3909+
3910+ if (orig_scop == NULL || (scop == NULL && input_test != NULL)) {
3911+ CANDL_error("Fail to open scop");
3912+ exit(1);
3913+ }
3914+
3915+ /* Check if we can compare the two scop
3916+ * The function compare only domains and access arrays
3917+ */
3918+ if (input_test != NULL && !candl_util_check_scop_list(orig_scop, scop))
3919+ CANDL_error("The two scop lists can't be compared");
3920+
3921+ /* Add more infos (depth, label, ...)
3922+ * Not important for the transformed scop
3923+ * TODO : the statements must be sorted to compute the statement label
3924+ * the problem is if the scop is reordered, the second transformed scop
3925+ * must be aligned with it
3926+ */
3927+ candl_scop_usr_init(orig_scop);
3928+
3929 /* Calculating dependences. */
3930- dependence = candl_dependence(program, options);
3931+ candl_dependence_add_extension(orig_scop, options);
3932
3933+ osl_scop_p s1 = orig_scop;
3934+ while (s1) {num_scops++; s1 = s1->next;}
3935+
3936+ s1 = orig_scop;
3937+ osl_scop_p s2 = scop;
3938 /* Calculating legality violations. */
3939- if (options->violgraph)
3940- violation = candl_violation(program, dependence, options);
3941+ if (input_test != NULL) {
3942+ CANDL_malloc(violations, candl_violation_p*, num_scops);
3943
3944- /* Printing data structures if asked. */
3945- if (options->structure)
3946- {
3947- fprintf(output, "Program:\n");
3948- candl_program_print(output, program);
3949- fprintf(output, "\nDependences:\n");
3950- candl_dependence_print(output, dependence);
3951- fprintf(output, "\nViolations:\n");
3952- candl_violation_print(output, violation);
3953+ for (i=0; i< num_scops; i++, s1 = s1->next, s2 = s2->next) {
3954+ dep = osl_generic_lookup(s1->extension,
3955+ OSL_URI_DEPENDENCE);
3956+ violations[i] = candl_violation(s1, dep, s2, options);
3957 }
3958+ }
3959+
3960+ /* Printing data structures if asked. */
3961+ if (options->structure) {
3962+
3963+ if (input_test != NULL) {
3964+ s1=orig_scop; s2=scop;
3965+ for (i=0; i< num_scops; i++, s1=s1->next, s2=s2->next) {
3966+ fprintf(output, "\033[33mORIGINAL SCOP:\033[00m\n");
3967+ osl_scop_print(output, s1);
3968+ fprintf(output, "\n\033[33mTRANSFORMED SCOP:\033[00m\n");
3969+ osl_scop_print(output, s2);
3970
3971-#ifdef CANDL_SUPPORTS_SCOPLIB
3972- if (options->readscop && options->writescop)
3973- candl_dependence_print_scop (input, output, dependence);
3974- else
3975- {
3976-#endif
3977- /* Printing dependence graph if asked or if there is no transformation. */
3978- if (options->depgraph || (program->transformation == NULL))
3979- {
3980- candl_dependence_pprint(output, dependence);
3981- if (options->view)
3982- candl_dependence_view(dependence);
3983- }
3984- /* Printing violation graph if asked and if there is a transformation. */
3985- if (options->violgraph && (program->transformation != NULL))
3986- {
3987- candl_violation_pprint(output, violation);
3988- if (options->view)
3989- candl_violation_view(violation);
3990- }
3991+ dep = osl_generic_lookup(s1->extension, OSL_URI_DEPENDENCE);
3992+ fprintf(output, "\n\033[33mDEPENDENCES GRAPH:\033[00m\n");
3993+ candl_dependence_pprint(output, dep);
3994+ fprintf(output, "\n\n\033[33mVIOLATIONS GRAPH:\033[00m\n");
3995+ candl_violation_pprint(output, violations[i]);
3996+ }
3997+ } else {
3998+ s1=orig_scop;
3999+ for (i=0; i< num_scops; i++, s1=s1->next) {
4000+ fprintf(output, "\033[33mORIGINAL SCOP:\033[00m\n");
4001+ osl_scop_print(output, s1);
4002
4003-#ifdef CANDL_SUPPORTS_SCOPLIB
4004+ dep = osl_generic_lookup(s1->extension, OSL_URI_DEPENDENCE);
4005+ fprintf(output, "\n\033[33mDEPENDENCES GRAPH:\033[00m\n");
4006+ candl_dependence_pprint(output, dep);
4007+ }
4008 }
4009-#endif
4010
4011+ } else if (input_test != NULL) {
4012+ /* Printing violation graph */
4013+ for (i=0; i< num_scops; i++) {
4014+ candl_violation_pprint(output, violations[i]);
4015+ if (options->view)
4016+ candl_violation_view(violations[i]);
4017+ }
4018+ } else if (options->outscop) {
4019+ /* Export to the scop format */
4020+ s1=orig_scop;
4021+ osl_scop_print(output, s1); //prints list
4022+ } else {
4023+ /* Printing dependence graph if asked or if there is no transformation. */
4024+ s1=orig_scop;
4025+ for(i=0; i< num_scops; i++, s1=s1->next){
4026+ dep = osl_generic_lookup(s1->extension, OSL_URI_DEPENDENCE);
4027+ fprintf(output, "\033[33mSCOP #%d:\033[00m\n", i+1);
4028+ candl_dependence_pprint(output, dep);
4029+ fprintf(output, "\n");
4030+ if (options->view)
4031+ candl_dependence_view(dep);
4032+ }
4033+ }
4034
4035 /* Being clean. */
4036- candl_violation_free(violation);
4037- candl_dependence_free(dependence);
4038- candl_program_free(program);
4039+ if (input_test != NULL) {
4040+ for (i=0; i< num_scops; i++)
4041+ candl_violation_free(violations[i]);
4042+ osl_scop_free(scop);
4043+ fclose(input_test);
4044+ }
4045+
4046+ // the dependence is freed with the scop
4047+ //osl_dependence_free(orig_dependence);
4048 candl_options_free(options);
4049- pip_close();
4050+ candl_scop_usr_cleanup(orig_scop);
4051+ osl_scop_free(orig_scop);
4052 fclose(input);
4053 fclose(output);
4054-
4055+ pip_close();
4056+
4057 return 0;
4058 }
4059diff --git a/source/ddv.c b/source/ddv.c
4060index 8ac06f5..7220198 100644
4061--- a/source/ddv.c
4062+++ b/source/ddv.c
4063@@ -6,8 +6,8 @@
4064 **---- \#/ --------------------------------------------------------**
4065 ** .-"#'-. First version: February 4th 2010 **
4066 **--- |"-.-"| -------------------------------------------------------**
4067- | |
4068- | |
4069+ | |
4070+ | |
4071 ******** | | *************************************************************
4072 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
4073 ******************************************************************************
4074@@ -41,13 +41,16 @@
4075 #include <stdlib.h>
4076 #include <stdio.h>
4077 #include <string.h>
4078-#include <candl/candl.h>
4079-
4080 #include <assert.h>
4081-
4082+#include <osl/statement.h>
4083+#include <osl/scop.h>
4084+#include <osl/extensions/dependence.h>
4085+#include <candl/macros.h>
4086+#include <candl/ddv.h>
4087+#include <candl/statement.h>
4088+#include <candl/piplib.h>
4089 #include <candl/piplib-wrapper.h>
4090
4091-
4092 #ifndef min
4093 # define min(x,y) (x < y ? x : y)
4094 #endif
4095@@ -55,6 +58,7 @@
4096 # define max(x,y) (x > y ? x : y)
4097 #endif
4098
4099+
4100 /******************************************************************************
4101 * Memory deallocation function *
4102 ******************************************************************************/
4103@@ -65,8 +69,7 @@
4104 *
4105 */
4106 CandlDDV*
4107-candl_ddv_malloc()
4108-{
4109+candl_ddv_malloc() {
4110 CandlDDV* dv = (CandlDDV*) malloc(sizeof(CandlDDV));
4111 dv->next = NULL;
4112 dv->data = NULL;
4113@@ -82,19 +85,17 @@ candl_ddv_malloc()
4114 *
4115 */
4116 CandlDDV*
4117-candl_ddv_alloc(int size)
4118-{
4119+candl_ddv_alloc(int size) {
4120 CandlDDV* dv = candl_ddv_malloc();
4121
4122 dv->data = (s_dv_descriptor*) malloc(size * sizeof(s_dv_descriptor));
4123 dv->length = size;
4124
4125 int i;
4126- for (i = 0; i < size; ++i)
4127- {
4128- dv->data[i].type = candl_dv_star;
4129- dv->data[i].value = 0;
4130- }
4131+ for (i = 0; i < size; ++i) {
4132+ dv->data[i].type = candl_dv_star;
4133+ dv->data[i].value = 0;
4134+ }
4135
4136 return dv;
4137 }
4138@@ -106,19 +107,17 @@ candl_ddv_alloc(int size)
4139 *
4140 */
4141 void
4142-candl_ddv_free(CandlDDV* dv)
4143-{
4144+candl_ddv_free(CandlDDV* dv) {
4145 CandlDDV* tmp;
4146 CandlDDV* next;
4147
4148- for (tmp = dv; tmp; )
4149- {
4150- next = tmp->next;
4151- if (tmp->data)
4152- free(tmp->data);
4153- free(tmp);
4154- tmp = next;
4155- }
4156+ for (tmp = dv; tmp; ) {
4157+ next = tmp->next;
4158+ if (tmp->data)
4159+ free(tmp->data);
4160+ free(tmp);
4161+ tmp = next;
4162+ }
4163
4164 }
4165
4166@@ -130,8 +129,7 @@ candl_ddv_free(CandlDDV* dv)
4167 *
4168 */
4169 void
4170-candl_ddv_set_type_at(CandlDDV* dv, e_dv_type type, int pos)
4171-{
4172+candl_ddv_set_type_at(CandlDDV* dv, e_dv_type type, int pos) {
4173 dv->data[pos].type = type;
4174 }
4175
4176@@ -143,19 +141,17 @@ candl_ddv_set_type_at(CandlDDV* dv, e_dv_type type, int pos)
4177 *
4178 */
4179 void
4180-candl_ddv_set_value_at(CandlDDV* dv, int value, int pos)
4181-{
4182+candl_ddv_set_value_at(CandlDDV* dv, int value, int pos) {
4183 dv->data[pos].value = value;
4184 }
4185
4186 /**
4187 * candl_ddv_set_type: Set the type of the dependence in
4188- * CANDL_UNSET, CANDL_RAW, CANDL_WAR, CANDL_WAW, CANDL_RAR.
4189+ * CANDL_UNDEFINED, CANDL_RAW, CANDL_WAR, CANDL_WAW, CANDL_RAR.
4190 *
4191 */
4192 void
4193-candl_ddv_set_deptype(CandlDDV* dv, int type)
4194-{
4195+candl_ddv_set_deptype(CandlDDV* dv, int type) {
4196 dv->deptype = type;
4197 }
4198
4199@@ -170,33 +166,30 @@ candl_ddv_set_deptype(CandlDDV* dv, int type)
4200 *
4201 */
4202 void
4203-candl_ddv_print(FILE* out, CandlDDV* dv)
4204-{
4205- if (!dv)
4206- {
4207- fprintf(out, "(null ddv)\n");
4208- return;
4209- }
4210+candl_ddv_print(FILE* out, CandlDDV* dv) {
4211+ if (!dv) {
4212+ fprintf(out, "(null ddv)\n");
4213+ return;
4214+ }
4215
4216 int i;
4217 fprintf(out, "loop_id=%d, (", dv->loop_id);
4218- for (i = 0; i < dv->length; ++i)
4219- {
4220- if (dv->data[i].type == candl_dv_star)
4221- fprintf(out, "*");
4222- else if (dv->data[i].type == candl_dv_eq)
4223- fprintf(out, "=");
4224- else if (dv->data[i].type == candl_dv_plus)
4225- fprintf(out, ">");
4226- else if (dv->data[i].type == candl_dv_minus)
4227- fprintf(out, "<");
4228- else if (dv->data[i].type == candl_dv_scalar)
4229- fprintf(out, "%d", dv->data[i].value);
4230- if (i < dv->length - 1)
4231- fprintf(out, ", ");
4232- else
4233- fprintf(out, ")\n");
4234- }
4235+ for (i = 0; i < dv->length; ++i) {
4236+ if (dv->data[i].type == candl_dv_star)
4237+ fprintf(out, "*");
4238+ else if (dv->data[i].type == candl_dv_eq)
4239+ fprintf(out, "=");
4240+ else if (dv->data[i].type == candl_dv_plus)
4241+ fprintf(out, ">");
4242+ else if (dv->data[i].type == candl_dv_minus)
4243+ fprintf(out, "<");
4244+ else if (dv->data[i].type == candl_dv_scalar)
4245+ fprintf(out, "%d", dv->data[i].value);
4246+ if (i < dv->length - 1)
4247+ fprintf(out, ", ");
4248+ else
4249+ fprintf(out, ")\n");
4250+ }
4251 }
4252
4253
4254@@ -206,24 +199,11 @@ candl_ddv_print(FILE* out, CandlDDV* dv)
4255
4256
4257 /**
4258- * Integer emptiness test on a given polyhedron.
4259- *
4260- */
4261-static
4262-int
4263-candl_ddv_has_point(CandlMatrix* system)
4264-{
4265- return pip_has_rational_point (system, NULL, 1);
4266-}
4267-
4268-
4269-/**
4270 * Recursively count the number of leaves in a QUAST.
4271 *
4272 */
4273 static
4274-int count_quast_leaves(PipQuast* q)
4275-{
4276+int count_quast_leaves(PipQuast* q) {
4277 if (!q)
4278 return 0;
4279 if (q->condition == NULL)
4280@@ -238,22 +218,19 @@ int count_quast_leaves(PipQuast* q)
4281 *
4282 */
4283 static
4284-void get_quast_leaves(PipQuast* q, PipList** leaves)
4285-{
4286+void get_quast_leaves(PipQuast* q, PipList** leaves) {
4287 if (!q)
4288 return;
4289- if (q->condition == NULL)
4290- {
4291- int i;
4292- for (i = 0; leaves[i]; ++i)
4293- ;
4294- leaves[i] = q->list;
4295- }
4296- else
4297- {
4298- get_quast_leaves(q->next_else, leaves);
4299- get_quast_leaves(q->next_then, leaves);
4300- }
4301+ if (q->condition == NULL) {
4302+ int i;
4303+ for (i = 0; leaves[i]; ++i)
4304+ ;
4305+ leaves[i] = q->list;
4306+ }
4307+ else {
4308+ get_quast_leaves(q->next_else, leaves);
4309+ get_quast_leaves(q->next_then, leaves);
4310+ }
4311 }
4312
4313
4314@@ -266,15 +243,16 @@ void get_quast_leaves(PipQuast* q, PipList** leaves)
4315 */
4316 static
4317 int
4318-candl_ddv_constant_val(CandlMatrix* system, int* val, int nb_par)
4319-{
4320+candl_ddv_constant_val(osl_relation_p system, int* val, int nb_par) {
4321 PipOptions * options;
4322 PipQuast * solution;
4323+ osl_relation_p context;
4324 int is_constant_val = 1;
4325 int cst;
4326 int cst_base = 42;
4327 int first = 1;
4328 int i, j;
4329+ int precision = system->precision;
4330
4331 // 1- Comute the lexmin of the system, to get a QUAST.
4332 options = pip_options_init();
4333@@ -282,54 +260,51 @@ candl_ddv_constant_val(CandlMatrix* system, int* val, int nb_par)
4334 options->Urs_parms = -1;
4335 options->Urs_unknowns = -1;
4336 options->Nq = 0;
4337- CandlMatrix* context = candl_matrix_malloc(0, nb_par + 2);
4338- solution = pip_solve(system, context, -1, options);
4339+
4340+ context = osl_relation_pmalloc(precision, 0, nb_par + 2);
4341+ solution = pip_solve_osl(system, context, -1, options);
4342
4343 if ((solution != NULL) &&
4344- ((solution->list != NULL) || (solution->condition != NULL)))
4345- {
4346- // 2- Traverse all leaves, ensure they have the same value.
4347- int nb_leaves = count_quast_leaves(solution);
4348- PipList* leaveslist[nb_leaves + 1];
4349- for (i = 0; i < nb_leaves + 1; ++i)
4350- leaveslist[i] = NULL;
4351- get_quast_leaves(solution, leaveslist);
4352-
4353- for (i = 0; i < nb_leaves; ++i)
4354- {
4355- PipList* list = leaveslist[i];
4356- if (list && list->vector)
4357- {
4358- PipVector* vect = list->vector;
4359- for (j = 0; j < nb_par; ++j)
4360- if (CANDL_get_si(vect->the_vector[j]) != 0)
4361- {
4362- is_constant_val = 0;
4363- break;
4364- }
4365- if (is_constant_val)
4366- {
4367- cst = CANDL_get_si(vect->the_vector[vect->nb_elements - 1]);
4368- if (first)
4369- {
4370- first = 0;
4371- cst_base = cst;
4372- }
4373- else if (! first && cst != cst_base)
4374- {
4375- is_constant_val = 0;
4376- break;
4377- }
4378- }
4379- else
4380- break;
4381- }
4382- }
4383+ ((solution->list != NULL) || (solution->condition != NULL))) {
4384+ // 2- Traverse all leaves, ensure they have the same value.
4385+ int nb_leaves = count_quast_leaves(solution);
4386+ PipList* leaveslist[nb_leaves + 1];
4387+ for (i = 0; i < nb_leaves + 1; ++i)
4388+ leaveslist[i] = NULL;
4389+ get_quast_leaves(solution, leaveslist);
4390+
4391+ for (i = 0; i < nb_leaves; ++i) {
4392+ PipList* list = leaveslist[i];
4393+ if (list && list->vector) {
4394+ PipVector* vect = list->vector;
4395+
4396+ // FIXME : check if precision is correct to use piplib
4397+
4398+ for (j = 0; j < nb_par; ++j)
4399+ if (!CANDL_zero_p(vect->the_vector[j])) {
4400+ is_constant_val = 0;
4401+ break;
4402+ }
4403+ if (is_constant_val) {
4404+ cst = CANDL_get_si(vect->the_vector[vect->nb_elements-1]);
4405+ if (first) {
4406+ first = 0;
4407+ cst_base = cst;
4408+ }
4409+ else if (! first && cst != cst_base) {
4410+ is_constant_val = 0;
4411+ break;
4412+ }
4413+ }
4414+ else
4415+ break;
4416+ }
4417 }
4418+ }
4419
4420 pip_quast_free(solution);
4421 pip_options_free(options);
4422- candl_matrix_free(context);
4423+ osl_relation_free(context);
4424
4425 if (is_constant_val)
4426 *val = cst_base;
4427@@ -345,98 +320,97 @@ candl_ddv_constant_val(CandlMatrix* system, int* val, int nb_par)
4428 */
4429 static
4430 CandlDDV*
4431-candl_ddv_create_from_dep(CandlDependence* dep, int loop_id, int ddv_size)
4432-{
4433+candl_ddv_create_from_dep(osl_dependence_p dep, int loop_id, int ddv_size) {
4434+ osl_relation_p mat = dep->domain;
4435+ osl_statement_p src = dep->stmt_source_ptr;
4436+ candl_statement_usr_p usr = src->usr;
4437+ CandlDDV* dv = candl_ddv_alloc(ddv_size);
4438+ int precision = src->domain->precision;
4439 int i, j;
4440 int pos;
4441- CandlMatrix* mat = dep->domain;
4442- CandlStatement* src = dep->source;
4443- CandlDDV* dv = candl_ddv_alloc(ddv_size);
4444+
4445 dv->loop_id = loop_id;
4446 dv->deptype = dep->type;
4447
4448 // Create the template of the system to operate on.
4449 // Add one dimension at the beginning, and one row for the extra constraint.
4450- int nb_par = src->domain->NbColumns - 2 - src->depth;
4451- CandlMatrix* testsyst =
4452- candl_matrix_malloc(mat->NbRows + 1, mat->NbColumns + 1);
4453- for (pos = 0; pos < mat->NbRows; ++pos)
4454- {
4455- CANDL_assign(testsyst->p[pos][0], mat->p[pos][0]);
4456- for (j = 1; j < mat->NbColumns; ++j)
4457- CANDL_assign(testsyst->p[pos][j + 1], mat->p[pos][j]);
4458- }
4459+ int nb_par = src->domain->nb_parameters;
4460+ osl_relation_p testsyst = osl_relation_pmalloc(precision,
4461+ mat->nb_rows + 1,
4462+ mat->nb_columns + 1);
4463+ for (pos = 0; pos < mat->nb_rows; ++pos) {
4464+ osl_int_assign(precision, &testsyst->m[pos][0], mat->m[pos][0]);
4465+ for (j = 1; j < mat->nb_columns; ++j)
4466+ osl_int_assign(precision, &testsyst->m[pos][j + 1],mat->m[pos][j]);
4467+ }
4468+
4469 int has_eq, has_pos, has_neg, has_cst;
4470 int scal1, scal2;
4471- for (i = 1; i <= ddv_size; ++i)
4472- {
4473- // Test for '='.
4474- CANDL_set_si(testsyst->p[pos][0], 0);
4475- CANDL_set_si(testsyst->p[pos][1 + i], 1);
4476- CANDL_set_si(testsyst->p[pos][1 + i + src->depth], -1);
4477- CANDL_set_si(testsyst->p[pos][testsyst->NbColumns - 1], 0);
4478- has_eq = candl_ddv_has_point(testsyst);
4479-
4480- // Test for '>'.
4481- CANDL_set_si(testsyst->p[pos][0], 1);
4482- CANDL_set_si(testsyst->p[pos][1 + i], 1);
4483- CANDL_set_si(testsyst->p[pos][1 + i + src->depth], -1);
4484- CANDL_set_si(testsyst->p[pos][testsyst->NbColumns - 1], -1);
4485- has_pos = candl_ddv_has_point(testsyst);
4486-
4487- // Test for '<'.
4488- CANDL_set_si(testsyst->p[pos][0], 1);
4489- CANDL_set_si(testsyst->p[pos][1 + i], -1);
4490- CANDL_set_si(testsyst->p[pos][1 + i + src->depth], 1);
4491- CANDL_set_si(testsyst->p[pos][testsyst->NbColumns - 1], -1);
4492- has_neg = candl_ddv_has_point(testsyst);
4493-
4494- // Test for constant distance.
4495- // min(x_R^i - x_S^i)
4496- // max(x_R^i - x_S^i) = - min(- x_R^i + x_S^i)
4497- CANDL_set_si(testsyst->p[pos][0], 0);
4498- CANDL_set_si(testsyst->p[pos][1], 1);
4499- CANDL_set_si(testsyst->p[pos][1 + i], -1);
4500- CANDL_set_si(testsyst->p[pos][1 + i + src->depth], 1);
4501- CANDL_set_si(testsyst->p[pos][testsyst->NbColumns - 1], 0);
4502- has_cst = candl_ddv_constant_val(testsyst, &scal1, nb_par);
4503-
4504+ for (i = 1; i <= ddv_size; ++i) {
4505+ // Test for '='.
4506+ osl_int_set_si(precision, &testsyst->m[pos][0], 0);
4507+ osl_int_set_si(precision, &testsyst->m[pos][1 + i], 1);
4508+ osl_int_set_si(precision, &testsyst->m[pos][1 + i + usr->depth], -1);
4509+ osl_int_set_si(precision, &testsyst->m[pos][testsyst->nb_columns-1], 0);
4510+ has_eq = pip_has_rational_point(testsyst, NULL, 1);
4511+
4512+ // Test for '>'.
4513+ osl_int_set_si(precision, &testsyst->m[pos][0], 1);
4514+ osl_int_set_si(precision, &testsyst->m[pos][1 + i], 1);
4515+ osl_int_set_si(precision, &testsyst->m[pos][1 + i + usr->depth], -1);
4516+ osl_int_set_si(precision, &testsyst->m[pos][testsyst->nb_columns-1], -1);
4517+ has_pos = pip_has_rational_point(testsyst, NULL, 1);
4518+
4519+ // Test for '<'.
4520+ osl_int_set_si(precision, &testsyst->m[pos][0], 1);
4521+ osl_int_set_si(precision, &testsyst->m[pos][1 + i], -1);
4522+ osl_int_set_si(precision, &testsyst->m[pos][1 + i + usr->depth], 1);
4523+ osl_int_set_si(precision, &testsyst->m[pos][testsyst->nb_columns-1], -1);
4524+ has_neg = pip_has_rational_point(testsyst, NULL, 1);
4525+
4526+ // Test for constant distance.
4527+ // min(x_R^i - x_S^i)
4528+ // max(x_R^i - x_S^i) = - min(- x_R^i + x_S^i)
4529+ osl_int_set_si(precision, &testsyst->m[pos][0], 0);
4530+ osl_int_set_si(precision, &testsyst->m[pos][1], 1);
4531+ osl_int_set_si(precision, &testsyst->m[pos][1 + i], -1);
4532+ osl_int_set_si(precision, &testsyst->m[pos][1 + i + usr->depth], 1);
4533+ osl_int_set_si(precision, &testsyst->m[pos][testsyst->nb_columns-1], 0);
4534+ has_cst = candl_ddv_constant_val(testsyst, &scal1, nb_par);
4535+
4536+ if (has_cst) {
4537+ osl_int_set_si(precision, &testsyst->m[pos][1 + i], 1);
4538+ osl_int_set_si(precision, &testsyst->m[pos][1 + i + usr->depth], -1);
4539+ osl_int_set_si(precision, &testsyst->m[pos][1], 1);
4540+ has_cst = candl_ddv_constant_val(testsyst, &scal2, nb_par);
4541+ scal2 *= -1;
4542 if (has_cst)
4543- {
4544- CANDL_set_si(testsyst->p[pos][1 + i], 1);
4545- CANDL_set_si(testsyst->p[pos][1 + i + src->depth], -1);
4546- CANDL_set_si(testsyst->p[pos][1], 1);
4547- has_cst = candl_ddv_constant_val(testsyst, &scal2, nb_par);
4548- scal2 *= -1;
4549- if (has_cst)
4550- has_cst = (scal1 == scal2);
4551- }
4552-
4553- if (has_cst && scal1 != 0)
4554- {
4555- candl_ddv_set_type_at (dv, candl_dv_scalar, i - 1);
4556- candl_ddv_set_value_at (dv, scal1, i - 1);
4557- }
4558- else if (has_pos && has_neg)
4559- candl_ddv_set_type_at (dv, candl_dv_star, i - 1);
4560- else if (has_pos)
4561- candl_ddv_set_type_at (dv, candl_dv_plus, i - 1);
4562- else if (has_neg)
4563- candl_ddv_set_type_at (dv, candl_dv_minus, i - 1);
4564- else if (has_eq)
4565- {
4566- candl_ddv_set_type_at (dv, candl_dv_eq, i - 1);
4567- candl_ddv_set_value_at (dv, 0, i - 1);
4568- }
4569-
4570- // Reset the constraint.
4571- CANDL_set_si(testsyst->p[pos][0], 0);
4572- CANDL_set_si(testsyst->p[pos][1], 0);
4573- CANDL_set_si(testsyst->p[pos][1 + i], 0);
4574- CANDL_set_si(testsyst->p[pos][1 + i + src->depth], 0);
4575- CANDL_set_si(testsyst->p[pos][testsyst->NbColumns - 1], 0);
4576+ has_cst = (scal1 == scal2);
4577 }
4578
4579+ if (has_cst && scal1 != 0) {
4580+ candl_ddv_set_type_at(dv, candl_dv_scalar, i - 1);
4581+ candl_ddv_set_value_at(dv, scal1, i - 1);
4582+ }
4583+ else if (has_pos && has_neg)
4584+ candl_ddv_set_type_at(dv, candl_dv_star, i - 1);
4585+ else if (has_pos)
4586+ candl_ddv_set_type_at(dv, candl_dv_plus, i - 1);
4587+ else if (has_neg)
4588+ candl_ddv_set_type_at(dv, candl_dv_minus, i - 1);
4589+ else if (has_eq) {
4590+ candl_ddv_set_type_at(dv, candl_dv_eq, i - 1);
4591+ candl_ddv_set_value_at(dv, 0, i - 1);
4592+ }
4593+
4594+ // Reset the constraint.
4595+ osl_int_set_si(precision, &testsyst->m[pos][0], 0);
4596+ osl_int_set_si(precision, &testsyst->m[pos][1], 0);
4597+ osl_int_set_si(precision, &testsyst->m[pos][1 + i], 0);
4598+ osl_int_set_si(precision, &testsyst->m[pos][1 + i + usr->depth], 0);
4599+ osl_int_set_si(precision, &testsyst->m[pos][testsyst->nb_columns-1], 0);
4600+ }
4601+
4602 return dv;
4603 }
4604
4605@@ -449,38 +423,39 @@ candl_ddv_create_from_dep(CandlDependence* dep, int loop_id, int ddv_size)
4606 *
4607 */
4608 CandlDDV*
4609-candl_ddv_extract_in_loop(CandlProgram* program, CandlDependence* deps,
4610- int loop_id)
4611-{
4612- CandlDependence* tmp;
4613+candl_ddv_extract_in_loop(osl_scop_p scop, osl_dependence_p deps,
4614+ int loop_id) {
4615+ osl_dependence_p tmp;
4616+ candl_statement_usr_p src_usr, dst_usr;
4617 CandlDDV* head = NULL;
4618 CandlDDV* last = NULL;
4619 int i;
4620
4621- for (tmp = deps; tmp; tmp = tmp->next)
4622- {
4623- CandlStatement* src = tmp->source;
4624- CandlStatement* dst = tmp->target;
4625-
4626- // Iterate on all dependences that lie within the given loop.
4627- for (i = 0; i < min(src->depth, dst->depth); ++i)
4628- if (src->index[i] == dst->index[i] && dst->index[i] == loop_id)
4629- break;
4630- if (i == min(src->depth, dst->depth))
4631- continue;
4632- // The dependence involves statement carried by the loop.
4633- // Convert it into dependence vector.
4634- CandlDDV* dv = candl_ddv_create_from_dep(tmp, loop_id, i + 1);
4635-
4636- // Append the dependence vector to the list.
4637- if (head == NULL)
4638- head = last = dv;
4639- else
4640- {
4641- last->next = dv;
4642- last = dv;
4643- }
4644+ for (tmp = deps; tmp; tmp = tmp->next) {
4645+ osl_statement_p src = tmp->stmt_source_ptr;
4646+ osl_statement_p dst = tmp->stmt_target_ptr;
4647+ src_usr = src->usr;
4648+ dst_usr = dst->usr;
4649+
4650+ // Iterate on all dependences that lie within the given loop.
4651+ for (i = 0; i < min(src_usr->depth, dst_usr->depth); ++i)
4652+ if (src_usr->index[i] == dst_usr->index[i] &&
4653+ dst_usr->index[i] == loop_id)
4654+ break;
4655+ if (i == min(src_usr->depth, dst_usr->depth))
4656+ continue;
4657+ // The dependence involves statement carried by the loop.
4658+ // Convert it into dependence vector.
4659+ CandlDDV* dv = candl_ddv_create_from_dep(tmp, loop_id, i + 1);
4660+
4661+ // Append the dependence vector to the list.
4662+ if (head == NULL)
4663+ head = last = dv;
4664+ else {
4665+ last->next = dv;
4666+ last = dv;
4667 }
4668+ }
4669
4670 return head;
4671 }
4672@@ -493,11 +468,10 @@ candl_ddv_extract_in_loop(CandlProgram* program, CandlDependence* deps,
4673 *
4674 */
4675 int
4676-candl_loops_are_permutable(CandlProgram* program, CandlDependence* deps,
4677- int loop_id1, int loop_id2)
4678-{
4679- CandlDDV* l1 = candl_ddv_extract_in_loop (program, deps, loop_id1);
4680- CandlDDV* l2 = candl_ddv_extract_in_loop (program, deps, loop_id2);
4681+candl_loops_are_permutable(osl_scop_p scop, osl_dependence_p deps,
4682+ int loop_id1, int loop_id2) {
4683+ CandlDDV* l1 = candl_ddv_extract_in_loop(scop, deps, loop_id1);
4684+ CandlDDV* l2 = candl_ddv_extract_in_loop(scop, deps, loop_id2);
4685
4686 // One of the loop do not carry any dependence.
4687 if (l1 == NULL || l2 == NULL)
4688@@ -511,79 +485,75 @@ candl_loops_are_permutable(CandlProgram* program, CandlDependence* deps,
4689
4690 int loop_dim_1 = -1;
4691 int loop_dim_2 = -1;
4692- int i, j;
4693- CandlStatement* stm;
4694- for (j = 0; j < program->nb_statements; ++j)
4695- {
4696- stm = program->statement[j];
4697- for (i = 0; i < stm->depth; ++i)
4698- if (stm->index[i] == loop_id1)
4699- loop_dim_1 = i;
4700- else if (stm->index[i] == loop_id2)
4701- loop_dim_2 = i;
4702- if (loop_dim_1 != -1 && loop_dim_2 != -1)
4703- break;
4704- }
4705+ int i;
4706+ candl_statement_usr_p usr;
4707+ osl_statement_p stm = scop->statement;
4708+ for (; stm != NULL; stm = stm->next) {
4709+ usr = stm->usr;
4710+ for (i = 0; i < usr->depth; ++i)
4711+ if (usr->index[i] == loop_id1)
4712+ loop_dim_1 = i;
4713+ else if (usr->index[i] == loop_id2)
4714+ loop_dim_2 = i;
4715+ if (loop_dim_1 != -1 && loop_dim_2 != -1)
4716+ break;
4717+ }
4718
4719 int is_pos_1 = 0;
4720 int is_neg_1 = 0;
4721 int is_pos_2 = 0;
4722 int is_neg_2 = 0;
4723 int is_star = 0;
4724- for (; dv; dv = dv->next)
4725- {
4726- switch (dv->data[loop_dim_1].type)
4727- {
4728- case candl_dv_plus:
4729- is_pos_1 = 1;
4730- break;
4731- case candl_dv_minus:
4732- is_neg_1 = 1;
4733- break;
4734- case candl_dv_scalar:
4735- if (dv->data[loop_dim_1].value > 0)
4736- is_pos_1 = 1;
4737- else if (dv->data[loop_dim_1].value < 0)
4738- is_neg_1 = 1;
4739- break;
4740- case candl_dv_star:
4741- is_star = 1;
4742- break;
4743- default:
4744- break;
4745- }
4746- switch (dv->data[loop_dim_2].type)
4747- {
4748- case candl_dv_plus:
4749- is_pos_2 = 1;
4750- break;
4751- case candl_dv_minus:
4752- is_neg_2 = 1;
4753- break;
4754- case candl_dv_scalar:
4755- if (dv->data[loop_dim_2].value > 0)
4756- is_pos_2 = 1;
4757- else if (dv->data[loop_dim_2].value < 0)
4758- is_neg_2 = 1;
4759- break;
4760- case candl_dv_star:
4761- is_star = 1;
4762- break;
4763- default:
4764- break;
4765- }
4766- if ((is_pos_1 && is_neg_1) || (is_pos_2 && is_neg_2) || is_star)
4767- {
4768- candl_ddv_free (l1);
4769- candl_ddv_free (l2);
4770- return 0;
4771- }
4772+ for (; dv; dv = dv->next) {
4773+ switch (dv->data[loop_dim_1].type) {
4774+ case candl_dv_plus:
4775+ is_pos_1 = 1;
4776+ break;
4777+ case candl_dv_minus:
4778+ is_neg_1 = 1;
4779+ break;
4780+ case candl_dv_scalar:
4781+ if (dv->data[loop_dim_1].value > 0)
4782+ is_pos_1 = 1;
4783+ else if (dv->data[loop_dim_1].value < 0)
4784+ is_neg_1 = 1;
4785+ break;
4786+ case candl_dv_star:
4787+ is_star = 1;
4788+ break;
4789+ default:
4790+ break;
4791 }
4792-
4793- candl_ddv_free (l1);
4794- candl_ddv_free (l2);
4795-
4796-
4797+ switch (dv->data[loop_dim_2].type) {
4798+ case candl_dv_plus:
4799+ is_pos_2 = 1;
4800+ break;
4801+ case candl_dv_minus:
4802+ is_neg_2 = 1;
4803+ break;
4804+ case candl_dv_scalar:
4805+ if (dv->data[loop_dim_2].value > 0)
4806+ is_pos_2 = 1;
4807+ else if (dv->data[loop_dim_2].value < 0)
4808+ is_neg_2 = 1;
4809+ break;
4810+ case candl_dv_star:
4811+ is_star = 1;
4812+ break;
4813+ default:
4814+ break;
4815+ }
4816+ if ((is_pos_1 && is_neg_1) || (is_pos_2 && is_neg_2) || is_star) {
4817+ candl_ddv_free(l1);
4818+ candl_ddv_free(l2);
4819+ return 0;
4820+ }
4821+ }
4822+
4823+ candl_ddv_free(l1);
4824+ candl_ddv_free(l2);
4825+
4826+
4827 return ! ((is_pos_1 && is_neg_2) || (is_neg_1 && is_pos_2));
4828 }
4829
4830diff --git a/source/dependence.c b/source/dependence.c
4831index 41afccf..c8a61dc 100644
4832--- a/source/dependence.c
4833+++ b/source/dependence.c
4834@@ -6,8 +6,8 @@
4835 **---- \#/ --------------------------------------------------------**
4836 ** .-"#'-. First version: september 18th 2003 **
4837 **--- |"-.-"| -------------------------------------------------------**
4838- | |
4839- | |
4840+ | |
4841+ | |
4842 ******** | | *************************************************************
4843 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
4844 ******************************************************************************
4845@@ -40,11 +40,20 @@
4846 #include <stdlib.h>
4847 #include <stdio.h>
4848 #include <string.h>
4849-#include <candl/candl.h>
4850-
4851-#include <candl/piplib-wrapper.h>
4852-
4853 #include <assert.h>
4854+#include <candl/macros.h>
4855+#include <candl/dependence.h>
4856+#include <candl/scop.h>
4857+#include <candl/statement.h>
4858+#include <candl/util.h>
4859+#include <candl/matrix.h>
4860+#include <candl/piplib.h>
4861+#include <candl/piplib-wrapper.h>
4862+#include <osl/macros.h>
4863+#include <osl/scop.h>
4864+#include <osl/statement.h>
4865+#include <osl/relation.h>
4866+#include <osl/extensions/dependence.h>
4867
4868 #ifdef CANDL_SUPPORTS_ISL
4869 # undef Q // Thank you polylib...
4870@@ -55,154 +64,106 @@
4871 #endif
4872
4873
4874-
4875-/******************************************************************************
4876- * Structure display function *
4877- ******************************************************************************/
4878-
4879-
4880 /**
4881- * candl_dependence_print_structure function:
4882- * Displays a CandlDependence structure (dependence) into a file (file,
4883- * possibly stdout) in a way that trends to be understandable without falling
4884- * in a deep depression or, for the lucky ones, getting a headache... It
4885- * includes an indentation level (level) in order to work with others
4886- * print_structure functions.
4887- * - 18/09/2003: first version.
4888+ * candl_dependence_get_relation_ref_source_in_dep function:
4889+ * This function return the corresponding osl_relation_p of
4890+ * the ref_source
4891 */
4892-void candl_dependence_print_structure(FILE* file,
4893- candl_dependence_p dependence,
4894- int level)
4895-{
4896- int j, first = 1;
4897-
4898- if (dependence != NULL)
4899- { /* Go to the right level. */
4900- for(j=0; j<level; j++)
4901- fprintf(file, "|\t");
4902- fprintf(file, "+-- CandlDependence\n");
4903- }
4904- else
4905- { for(j=0; j<level; j++)
4906- fprintf(file, "|\t");
4907- fprintf(file, "+-- NULL dependence\n");
4908- }
4909-
4910- while (dependence != NULL)
4911- { if (!first)
4912- { /* Go to the right level. */
4913- for(j=0; j<level; j++)
4914- fprintf(file, "|\t");
4915- fprintf(file, "| CandlDependence\n");
4916- }
4917- else
4918- first = 0;
4919-
4920- /* A blank line. */
4921- for(j=0; j<=level+1; j++)
4922- fprintf(file, "|\t");
4923- fprintf(file, "\n");
4924-
4925- /* Go to the right level and print the type. */
4926- for(j=0; j<=level; j++)
4927- fprintf(file, "|\t");
4928- fprintf(file, "Type: ");
4929- switch (dependence->type)
4930- {
4931- case CANDL_UNSET : fprintf(file, "UNSET\n"); break;
4932- case CANDL_RAW : fprintf(file, "RAW (flow)\n"); break;
4933- case CANDL_WAR : fprintf(file, "WAR (anti)\n"); break;
4934- case CANDL_WAW : fprintf(file, "WAW (output)\n"); break;
4935- case CANDL_RAR : fprintf(file, "RAR (input)\n"); break;
4936- case CANDL_RAW_SCALPRIV : fprintf(file, "RAW_SCALPRIV (scalar priv)\n"); break;
4937- default : fprintf(file, "unknown\n"); break;
4938- }
4939-
4940- /* A blank line. */
4941- for(j=0; j<=level+1; j++)
4942- fprintf(file, "|\t");
4943- fprintf(file, "\n");
4944-
4945- /* Go to the right level and print the depth. */
4946- for(j=0; j<=level; j++)
4947- fprintf(file, "|\t");
4948- fprintf(file, "Depth: %d\n", dependence->depth);
4949-
4950- /* A blank line. */
4951- for(j=0; j<=level+1; j++)
4952- fprintf(file, "|\t");
4953- fprintf(file, "\n");
4954-
4955- /* Print the source statement. */
4956- candl_statement_print_structure(file, dependence->source, level+1);
4957-
4958- /* Print the target statement. */
4959- candl_statement_print_structure(file, dependence->target, level+1);
4960-
4961- /* Print the dependence polyhedron. */
4962- candl_matrix_print_structure(file, dependence->domain, level+1);
4963-
4964- dependence = dependence->next;
4965-
4966- /* Next line. */
4967- if (dependence != NULL)
4968- { for (j=0; j<=level; j++)
4969- fprintf(file, "|\t");
4970- fprintf(file, "V\n");
4971- }
4972- }
4973+osl_relation_p
4974+candl_dependence_get_relation_ref_source_in_dep(osl_dependence_p tmp) {
4975+ if (tmp->ref_source_access_ptr != NULL)
4976+ return tmp->ref_source_access_ptr;
4977+ int count = 0;
4978+ osl_relation_p elt = NULL;
4979+ osl_relation_list_p access;
4980+ access = tmp->stmt_source_ptr->access;
4981+ for (; access != NULL ; access = access->next) {
4982+ elt = access->elt;
4983+ if (count == tmp->ref_source)
4984+ break;
4985+ count++;
4986+ }
4987+ tmp->ref_source_access_ptr = elt;
4988+ return elt;
4989+}
4990
4991- /* The last line. */
4992- for(j=0; j<=level; j++)
4993- fprintf(file, "|\t");
4994- fprintf(file, "\n");
4995+/**
4996+ * candl_dependence_get_relation_ref_target_in_dep function:
4997+ * same as candl_dependence_get_relation_ref_source_in_dep but for the target
4998+ */
4999+osl_relation_p
5000+candl_dependence_get_relation_ref_target_in_dep(osl_dependence_p tmp) {
5001+ if (tmp->ref_target_access_ptr != NULL)
5002+ return tmp->ref_target_access_ptr;
5003+ int count = 0;
5004+ osl_relation_list_p access;
5005+ osl_relation_p elt = NULL;
5006+ access = tmp->stmt_target_ptr->access;
5007+ for (; access != NULL ; access = access->next) {
5008+ elt = access->elt;
5009+ if (count == tmp->ref_target)
5010+ break;
5011+ count++;
5012+ }
5013+ tmp->ref_target_access_ptr = elt;
5014+ return elt;
5015 }
5016
5017
5018-/* candl_dependence_print function:
5019- * This function prints the content of a CandlDependence structure (dependence)
5020- * into a file (file, possibly stdout).
5021+
5022+/**
5023+ * candl_dependence_get_array_refs_in_dep function:
5024+ * This function return the array indices referenced in the
5025+ * dependence.
5026 */
5027-void candl_dependence_print(FILE * file, candl_dependence_p dependence)
5028-{
5029- candl_dependence_print_structure(file, dependence, 0);
5030+void candl_dependence_get_array_refs_in_dep(osl_dependence_p tmp,
5031+ int* refs, int* reft) {
5032+ if (! tmp)
5033+ return;
5034+
5035+ osl_relation_p src, targ;
5036+
5037+ src = candl_dependence_get_relation_ref_source_in_dep(tmp);
5038+ targ = candl_dependence_get_relation_ref_target_in_dep(tmp);
5039+
5040+ *refs = osl_relation_get_array_id(src);
5041+
5042+ *reft = osl_relation_get_array_id(targ);
5043 }
5044
5045
5046-/* candl_dependence_pprint function:
5047- * This function prints the content of a CandlDependence structure (dependence)
5048+/* osl_dependence_pprint function:
5049+ * This function prints the content of a osl_dependence_p structure (dependence)
5050 * into a file (file, possibly stdout) as a Graphviz input file.
5051 * See http://www.graphviz.org
5052 * - 08/12/2005: first version.
5053 */
5054-void candl_dependence_pprint(FILE * file, candl_dependence_p dependence)
5055-{
5056+void candl_dependence_pprint(FILE * file, osl_dependence_p dependence) {
5057 int i = 0;
5058-
5059+
5060 fprintf(file, "digraph G {\n");
5061
5062 fprintf(file, "# Data Dependence Graph\n");
5063 fprintf(file, "# Generated by Candl "CANDL_RELEASE" "CANDL_VERSION" bits\n");
5064- while (dependence != NULL)
5065- {
5066- fprintf(file, " S%d -> S%d [label=\" ", dependence->source->label,
5067- dependence->target->label);
5068- switch (dependence->type)
5069- {
5070- case CANDL_UNSET : fprintf(file, "UNSET"); break;
5071- case CANDL_RAW : fprintf(file, "RAW") ; break;
5072- case CANDL_WAR : fprintf(file, "WAR") ; break;
5073- case CANDL_WAW : fprintf(file, "WAW") ; break;
5074- case CANDL_RAR : fprintf(file, "RAR") ; break;
5075- case CANDL_RAW_SCALPRIV : fprintf(file, "RAW_SCALPRIV (scalar-priv)") ; break;
5076- default : fprintf(file, "unknown"); break;
5077- }
5078- fprintf(file, " depth %d, ref %d->%d \"];\n", dependence->depth,
5079- dependence->ref_source,
5080- dependence->ref_target);
5081- dependence = dependence->next;
5082- i++;
5083+ while (dependence != NULL) {
5084+ fprintf(file, " S%d -> S%d [label=\" ", dependence->label_source,
5085+ dependence->label_target);
5086+ switch (dependence->type) {
5087+ case OSL_UNDEFINED : fprintf(file, "UNSET"); break;
5088+ case OSL_DEPENDENCE_RAW : fprintf(file, "RAW") ; break;
5089+ case OSL_DEPENDENCE_WAR : fprintf(file, "WAR") ; break;
5090+ case OSL_DEPENDENCE_WAW : fprintf(file, "WAW") ; break;
5091+ case OSL_DEPENDENCE_RAR : fprintf(file, "RAR") ; break;
5092+ case OSL_DEPENDENCE_RAW_SCALPRIV :
5093+ fprintf(file, "RAW_SCALPRIV (scalar-priv)") ; break;
5094+ default : fprintf(file, "unknown"); break;
5095 }
5096+ fprintf(file, " depth %d, ref %d->%d \"];\n", dependence->depth,
5097+ dependence->ref_source,
5098+ dependence->ref_target);
5099+ dependence = dependence->next;
5100+ i++;
5101+ }
5102
5103 if (i>4)
5104 fprintf(file, "# Number of edges = %i\n}\n", i);
5105@@ -217,135 +178,25 @@ void candl_dependence_pprint(FILE * file, candl_dependence_p dependence)
5106 * dependence graph.
5107 * - 20/03/2006: first version.
5108 */
5109-void candl_dependence_view(candl_dependence_p dependence)
5110-{
5111+void candl_dependence_view(osl_dependence_p dep) {
5112 FILE * temp_output;
5113-
5114- temp_output = fopen(CANDL_TEMP_OUTPUT, "w");
5115- candl_dependence_pprint(temp_output, dependence);
5116+ temp_output = fopen(CANDL_TEMP_OUTPUT,"w+");
5117+ candl_dependence_pprint(temp_output, dep);
5118 fclose(temp_output);
5119- system("(dot -Tps "CANDL_TEMP_OUTPUT" | gv - &) && rm -f "CANDL_TEMP_OUTPUT);
5120-}
5121-
5122-
5123-/**
5124- * Returns a string containing the dependence, formatted to fit the
5125- * .scop representation.
5126- *
5127- */
5128-static
5129-char*
5130-candl_program_deps_to_string(CandlDependence* dependence)
5131-{
5132- CandlDependence* tmp = dependence;
5133- int refs = 0, reft = 0;
5134- int i, j, k;
5135- int nb_deps;
5136- int buffer_size = 2048;
5137- int szbuff;
5138- char* buffer = (char*) malloc(buffer_size * sizeof(char));
5139- char buff[1024];
5140- char* type;
5141- char* pbuffer;
5142-
5143- for (tmp = dependence, nb_deps = 0; tmp; tmp = tmp->next, ++nb_deps)
5144+ /* check the return to remove the warning compilation */
5145+ if(system("dot -Tps "CANDL_TEMP_OUTPUT" | gv - && rm -f "CANDL_TEMP_OUTPUT" &"))
5146 ;
5147- sprintf(buffer, "# Number of dependences\n%d\n", nb_deps);
5148- if (nb_deps)
5149- {
5150- for (tmp = dependence, nb_deps = 1; tmp; tmp = tmp->next, ++nb_deps)
5151- {
5152- /* Compute the type of the dependence, and the array id
5153- accessed. */
5154- switch (tmp->type)
5155- {
5156- case CANDL_UNSET:
5157- type = "UNSET";
5158- break;
5159- case CANDL_RAW:
5160- type = "RAW #(flow)";
5161- refs = CANDL_get_si(tmp->source->written->p[tmp->ref_source][0]);
5162- reft = CANDL_get_si(tmp->target->read->p[tmp->ref_target][0]);
5163- break;
5164- case CANDL_WAR:
5165- type = "WAR #(anti)";
5166- refs = CANDL_get_si(tmp->source->read->p[tmp->ref_source][0]);
5167- reft = CANDL_get_si(tmp->target->written->p[tmp->ref_target][0]);
5168- break;
5169- case CANDL_WAW:
5170- type = "WAW #(output)";
5171- refs = CANDL_get_si(tmp->source->written->p[tmp->ref_source][0]);
5172- reft = CANDL_get_si(tmp->target->written->p[tmp->ref_target][0]);
5173- break;
5174- case CANDL_RAR:
5175- type = "RAR #(input)";
5176- refs = CANDL_get_si(tmp->source->read->p[tmp->ref_source][0]);
5177- reft = CANDL_get_si(tmp->target->read->p[tmp->ref_target][0]);
5178- break;
5179- case CANDL_RAW_SCALPRIV:
5180- type = "RAW_SCALPRIV #(scalar priv)";
5181- refs = CANDL_get_si(tmp->source->written->p[tmp->ref_source][0]);
5182- reft = CANDL_get_si(tmp->target->read->p[tmp->ref_target][0]);
5183- break;
5184- default:
5185- exit(1);
5186- break;
5187- }
5188- /* Quick consistency check. */
5189- if (refs != reft)
5190- CANDL_FAIL("Internal error. refs != reft\n");
5191-
5192- /* Output dependence information. */
5193- sprintf(buff, "# Description of dependence %d\n"
5194- "# type\n%s\n# From statement id\n%d\n"
5195- "# To statement id\n%d\n# Depth \n%d\n# Array id\n%d\n"
5196- "# Dependence domain\n%d %d\n", nb_deps, type,
5197- tmp->source->label, tmp->target->label, tmp->depth,
5198- refs, tmp->domain->NbRows, tmp->domain->NbColumns);
5199- strcat(buffer, buff);
5200- /* Output dependence domain. */
5201- pbuffer = buffer + strlen(buffer);
5202- for (i = 0; i < tmp->domain->NbRows; ++i)
5203- {
5204- for (j = 0; j < tmp->domain->NbColumns; ++j)
5205- {
5206- sprintf(buff, "%lld ", CANDL_get_si(tmp->domain->p[i][j]));
5207- szbuff = strlen(buff);
5208- if (szbuff == 2)
5209- *(pbuffer++) = ' ';
5210- for (k = 0; k < szbuff; ++k)
5211- *(pbuffer++) = buff[k];
5212- }
5213- *(pbuffer++) = '\n';
5214- }
5215- *(pbuffer++) = '\0';
5216- /* Increase the buffer size if needed. Conservatively assume a
5217- dependence is never larger than 2k. */
5218- szbuff = strlen(buffer);
5219- if (szbuff + 2048 > buffer_size)
5220- {
5221- buffer = (char*) realloc(buffer, (buffer_size *= 2) *
5222- sizeof(char));
5223- if (buffer == NULL)
5224- CANDL_FAIL("Error: memory overflow");
5225- buffer[szbuff] = '\0';
5226- }
5227- }
5228- }
5229-
5230- return buffer;
5231 }
5232
5233+
5234 #ifdef CANDL_SUPPORTS_ISL
5235
5236-struct isl_set*
5237-isl_set_from_piplib_matrix(struct isl_ctx* ctx,
5238- PipMatrix* matrix,
5239- int nparam);
5240-PipMatrix*
5241-isl_set_to_piplib_matrix(struct isl_ctx* ctx,
5242- struct isl_set* set,
5243- int nparam);
5244+struct isl_set* isl_set_from_piplib_matrix(struct isl_ctx* ctx,
5245+ osl_relation_p matrix,
5246+ int nparam);
5247+osl_relation_p isl_set_to_piplib_matrix(struct isl_ctx* ctx,
5248+ struct isl_set* set,
5249+ int nparam);
5250 /**
5251 * candl_dependence_isl_simplify function:
5252 *
5253@@ -353,33 +204,35 @@ isl_set_to_piplib_matrix(struct isl_ctx* ctx,
5254 * Useful for polyhedra that contain large coefficient values.
5255 *
5256 */
5257-CandlDependence* candl_dependence_isl_simplify(CandlDependence* dep,
5258- CandlProgram* program)
5259-{
5260- if (dep == NULL || program == NULL)
5261+osl_dependence_p candl_dependence_isl_simplify(osl_dependence_p dep,
5262+ osl_scop_p scop) {
5263+ if (dep == NULL || scop == NULL)
5264 return dep;
5265
5266- CandlDependence* tmp;
5267- PipMatrix* context = (PipMatrix*) program->context;
5268- int nparam = context->NbColumns - 2;
5269-
5270- struct isl_ctx* ctx = isl_ctx_alloc ();
5271-
5272- for (tmp = dep; tmp; tmp = tmp->next)
5273- {
5274- // 1- Convert the dependence polyhedron into ISL set.
5275- struct isl_set* set =
5276- isl_set_from_piplib_matrix(ctx, tmp->domain, nparam);
5277-
5278- // 2- Simplify the ISL set.
5279- set = isl_set_detect_equalities(set);
5280-
5281- // 3- Convert back into Candl matrix representation.
5282- PipMatrix* newdom = isl_set_to_piplib_matrix(ctx, set, nparam);
5283- isl_set_free (set);
5284- candl_matrix_free (tmp->domain);
5285- tmp->domain = (CandlMatrix*) newdom;
5286- }
5287+ osl_dependence_p tmp;
5288+ osl_relation_p context = scop->context;
5289+ int nparam = context->nb_parameters;
5290+
5291+ struct isl_ctx* ctx = isl_ctx_alloc();
5292+
5293+ for (tmp = dep; tmp; tmp = tmp->next) {
5294+ // 1- Convert the dependence polyhedron into ISL set.
5295+
5296+ struct isl_set* set = isl_set_from_piplib_matrix(ctx, tmp->domain, nparam);
5297+
5298+ // 2- Simplify the ISL set.
5299+ set = isl_set_detect_equalities(set);
5300+
5301+ // 3- Convert back into Candl matrix representation.
5302+ osl_relation_p newdom = isl_set_to_piplib_matrix(ctx, set, nparam);
5303+ isl_set_free(set);
5304+ newdom->nb_output_dims = tmp->domain->nb_output_dims;
5305+ newdom->nb_input_dims = tmp->domain->nb_input_dims;
5306+ newdom->nb_local_dims = tmp->domain->nb_local_dims;
5307+ newdom->nb_parameters = tmp->domain->nb_parameters;
5308+ osl_relation_free(tmp->domain);
5309+ tmp->domain = newdom;
5310+ }
5311
5312 /// FIXME: Some dead ref.
5313 //isl_ctx_free (ctx);
5314@@ -390,476 +243,76 @@ CandlDependence* candl_dependence_isl_simplify(CandlDependence* dep,
5315 #endif
5316
5317
5318-
5319-/**
5320- * candl_dependence_print_scop function:
5321- * This function adds to the .scop file provided as the 'input' the
5322- * optional tags to represent the dependences 'dependence' of the
5323- * program. Finally, it prints the updated .scop to the file 'output'.
5324- *
5325- *
5326- */
5327-#ifdef CANDL_SUPPORTS_SCOPLIB
5328-/**
5329- * Read one dependence from a string.
5330- *
5331+/* candl_dependence_init_fields:
5332+ * Set the various other fields of the dependence structure
5333 */
5334-static
5335-CandlDependence* candl_dependence_read_one_dep(char* str, char** next,
5336- CandlProgram* program)
5337-{
5338- CandlDependence* dep = candl_dependence_malloc();
5339- CandlMatrix* msource = NULL;
5340- CandlMatrix* mtarget = NULL;
5341- char buffer[1024];
5342-
5343- int i, j, k;
5344- int id;
5345- int id2;
5346- /* # Description of dependence xxx */
5347- for (; *str != '\n'; ++str);
5348- ++str;
5349-
5350- /* # type */
5351- for (; *str != '\n'; ++str);
5352- ++str;
5353-
5354- /* {RAW,RAR,WAR,WAW} #(type) */
5355- for (i = 0; *str != ' '; ++str, ++i)
5356- buffer[i] = *str;
5357- buffer[i] = '\0';
5358- if (! strcmp(buffer, "RAW"))
5359- dep->type = CANDL_RAW;
5360- else if (! strcmp(buffer, "RAR"))
5361- dep->type = CANDL_RAR;
5362- else if (! strcmp(buffer, "WAR"))
5363- dep->type = CANDL_WAR;
5364- else if (! strcmp(buffer, "WAW"))
5365- dep->type = CANDL_WAW;
5366- else if (! strcmp(buffer, "RAW_SCALPRIV"))
5367- dep->type = CANDL_RAW_SCALPRIV;
5368- for (; *str != '\n'; ++str);
5369- ++str;
5370-
5371- /* # From statement xxx */
5372- for (; *str != '\n'; ++str);
5373- ++str;
5374- /* stmt-id */
5375- for (i = 0; *str != '\n'; ++str, ++i)
5376- buffer[i] = *str;
5377- ++str;
5378- buffer[i] = '\0';
5379- id = atoi(buffer);
5380- for (i = 0; i < program->nb_statements; ++i)
5381- if (program->statement[i]->label == id)
5382- {
5383- dep->source = program->statement[i];
5384- break;
5385- }
5386-
5387- /* # To statement xxx */
5388- for (; *str != '\n'; ++str);
5389- ++str;
5390- /* stmt-id */
5391- for (i = 0; *str != '\n'; ++str, ++i)
5392- buffer[i] = *str;
5393- ++str;
5394- buffer[i] = '\0';
5395- id = atoi(buffer);
5396- for (i = 0; i < program->nb_statements; ++i)
5397- if (program->statement[i]->label == id)
5398- {
5399- dep->target = program->statement[i];
5400- break;
5401- }
5402-
5403- /* # Depth */
5404- for (; *str != '\n'; ++str);
5405- ++str;
5406- /* depth */
5407- for (i = 0; *str != '\n'; ++str, ++i)
5408- buffer[i] = *str;
5409- ++str;
5410- buffer[i] = '\0';
5411- dep->depth = atoi(buffer);
5412-
5413- /* # Array id */
5414- for (; *str != '\n'; ++str);
5415- ++str;
5416- /* array-id */
5417- for (i = 0; *str != '\n'; ++str, ++i)
5418- buffer[i] = *str;
5419- ++str;
5420- buffer[i] = '\0';
5421- id = atoi(buffer);
5422- switch (dep->type)
5423- {
5424- case CANDL_RAW:
5425- case CANDL_RAW_SCALPRIV:
5426- msource = dep->source->written;
5427- mtarget = dep->target->read;
5428- break;
5429- case CANDL_WAR:
5430- msource = dep->source->read;
5431- mtarget = dep->target->written;
5432- break;
5433- case CANDL_WAW:
5434- msource = dep->source->written;
5435- mtarget = dep->target->written;
5436- break;
5437- case CANDL_RAR:
5438- msource = dep->source->read;
5439- mtarget = dep->target->read;
5440- break;
5441- default:
5442- exit(1);
5443+void candl_dependence_init_fields(osl_scop_p scop, osl_dependence_p dep) {
5444+
5445+ osl_statement_p iter;
5446+ candl_statement_usr_p usr;
5447+ osl_relation_p array_s, array_t;
5448+
5449+ /* source statement */
5450+ iter = scop->statement;
5451+ for (; iter != NULL ; iter = iter->next) {
5452+ usr = iter->usr;
5453+ if (usr->label == dep->label_source) {
5454+ dep->stmt_source_ptr = iter;
5455 break;
5456 }
5457- for (i = 0; i < msource->NbRows && msource->p[i][0] != id; ++i)
5458- ;
5459- if (i < msource->NbRows)
5460- dep->ref_source = i;
5461- for (i = 0; i < mtarget->NbRows && mtarget->p[i][0] != id; ++i)
5462- ;
5463- if (i < mtarget->NbRows)
5464- dep->ref_target = i;
5465-
5466- /* # Dependence domain */
5467- for (; *str != '\n'; ++str);
5468- ++str;
5469-
5470- /* nb-row nb-col */
5471- for (i = 0; *str != ' '; ++str, ++i)
5472- buffer[i] = *str;
5473- ++str;
5474- buffer[i] = '\0';
5475- id = atoi(buffer);
5476- for (i = 0; *str != '\n'; ++str, ++i)
5477- buffer[i] = *str;
5478- ++str;
5479- buffer[i] = '\0';
5480- id2 = atoi(buffer);
5481-
5482- dep->domain = candl_matrix_malloc(id, id2);
5483- /* Read matrix elements. */
5484- for (j = 0; j < id; ++j)
5485- {
5486- for (k = 0; k < id2; ++k)
5487- {
5488- while (*str && *str == ' ')
5489- str++;
5490- for (i = 0; *str != '\n' && *str != ' '; ++str, ++i)
5491- buffer[i] = *str;
5492- buffer[i] = '\0';
5493- ++str;
5494- CANDL_set_si(dep->domain->p[j][k], atoi(buffer));
5495- }
5496- if (*(str - 1) != '\n')
5497- {
5498- for (; *str != '\n'; ++str);
5499- ++str;
5500- }
5501- }
5502- /* Store the next character in the string to be analyzed. */
5503- *next = str;
5504-
5505- return dep;
5506-}
5507-
5508-/**
5509- * Retrieve a CandlDependence list from the option tag in the scop.
5510- *
5511- */
5512-CandlDependence* candl_dependence_read_from_scop(scoplib_scop_p scop,
5513- CandlProgram* program)
5514-{
5515- CandlDependence* first = NULL;
5516- CandlDependence* currdep = NULL;
5517-
5518- char* deps = scoplib_scop_tag_content(scop,
5519- "<dependence-polyhedra>",
5520- "</dependence-polyhedra>");
5521-
5522- /* No dependence, nothing to do. */
5523- if (deps == NULL)
5524- return NULL;
5525-
5526- /* Keep the starting address of the array. */
5527- char* base = deps;
5528-
5529- int i;
5530- int depcount;
5531- /* Get the number of dependences. */
5532- char buffer_nb[32];
5533- /* # Number of dependences */
5534- for (; *deps != '\n'; ++deps);
5535- ++deps;
5536- for (i = 0; *deps != '\n'; ++i, ++deps)
5537- buffer_nb[i] = *deps;
5538- buffer_nb[i] = '\0';
5539- ++deps;
5540- int nbdeps = atoi (buffer_nb);
5541- char* next;
5542-
5543- /* For each of them, read 1 and shift of the read size. */
5544- for (depcount = 0; depcount < nbdeps; ++depcount)
5545- {
5546- CandlDependence* adep =
5547- candl_dependence_read_one_dep(deps, &next, program);
5548- if (first == NULL)
5549- currdep = first = adep;
5550- else
5551- {
5552- currdep->next = adep;
5553- currdep = currdep->next;
5554- }
5555- deps = next;
5556- }
5557-
5558- /* Be clean. */
5559- free(base);
5560-
5561- return first;
5562-}
5563-
5564-/**
5565- * Update the scop option tag with the dependence list.
5566- *
5567- */
5568-void candl_dependence_update_scop_with_deps(scoplib_scop_p scop,
5569- CandlDependence* dependence)
5570-{
5571- char* start;
5572- char* stop;
5573- char* content;
5574- char* olddeps = NULL;
5575- char* newdeps;
5576- char* newopttags;
5577- char* curr;
5578- char* tmp;
5579- int size = 0;
5580- int size_newdeps;
5581- int size_olddeps = 0;
5582- int size_optiontags;
5583-
5584- start = stop = scop->optiontags;
5585- /* Get the candl tag, if any. */
5586- content = scoplib_scop_tag_content(scop, "<candl>", "</candl>");
5587- if (content)
5588- {
5589- /* Get the dependence tag, if any. */
5590- olddeps = scoplib_scop_tag_content_from_string
5591- (content, "<dependence-polyhedra>", "</dependence-polyhedra>");
5592- /* Seek for the correct start/stop characters to insert
5593- dependences. */
5594- if (olddeps)
5595- {
5596- size = size_olddeps = strlen(olddeps);
5597- while (start && *start && strncmp(start, olddeps, size))
5598- ++start;
5599- stop = start + size;
5600- }
5601- else
5602- {
5603- size = strlen(content);
5604- while (start && *start && strncmp(start, content, size))
5605- ++start;
5606- stop = start;
5607- }
5608- }
5609-
5610- /* Convert the program dependences to dotscop representation. */
5611- newdeps = candl_program_deps_to_string(dependence);
5612-
5613- /* Compute the new size of the full options tags, and allocate a new
5614- string. */
5615- size_newdeps = newdeps ? strlen(newdeps) : 0;
5616- size_optiontags = scop->optiontags ? strlen(scop->optiontags) : 0;
5617- if (content == NULL)
5618- size = strlen("<candl>") + strlen("</candl>") +
5619- strlen("<dependence-polyhedra>")
5620- + strlen("</dependence-polyhedra>");
5621- else if (olddeps == NULL)
5622- size = strlen("<dependence-polyhedra>") + strlen("</dependence-polyhedra>");
5623- else
5624- size = 0;
5625- newopttags = (char*) malloc((size_newdeps + size_optiontags
5626- - size_olddeps + size + 1)
5627- * sizeof(char));
5628- if (newopttags == NULL)
5629- CANDL_FAIL("Error: memory overflow");
5630- curr = newopttags;
5631-
5632- /* Copy the beginning of the options. */
5633- for (tmp = scop->optiontags; tmp != start; ++tmp)
5634- *(curr++) = *tmp;
5635- *curr = '\0';
5636- /* Copy the candl tags, if needed. */
5637- if (content == NULL)
5638- {
5639- strcat(newopttags, "<candl>\n");
5640- curr += strlen("<candl>\n");
5641- }
5642- if (olddeps == NULL)
5643- {
5644- strcat(newopttags, "<dependence-polyhedra>\n");
5645- curr += strlen("<dependence-polyhedra>\n");
5646- }
5647- /* Copy the program dependences. */
5648- for (tmp = newdeps; tmp && *tmp; ++tmp)
5649- *(curr++) = *tmp;
5650- *curr = '\0';
5651- /* Copy the candl tags, if needed. */
5652- if (olddeps == NULL)
5653- {
5654- strcat(curr, "</dependence-polyhedra>\n");
5655- curr += strlen("</dependence-polyhedra>\n");
5656- }
5657- if (content == NULL)
5658- {
5659- strcat(curr, "</candl>\n");
5660- curr += strlen("</candl>\n");
5661- }
5662- /* Copy the remainder of the options. */
5663- for (tmp = stop; tmp && *tmp; ++tmp)
5664- *(curr++) = *tmp;
5665- *curr = '\0';
5666-
5667- if (scop->optiontags)
5668- free(scop->optiontags);
5669- scop->optiontags = newopttags;
5670-
5671- /* Be clean. */
5672- if (content)
5673- free(content);
5674- if (olddeps)
5675- free(olddeps);
5676- if (newdeps)
5677- free(newdeps);
5678-}
5679-
5680-/**
5681- * Print the scop, containing the list of dependences.
5682- *
5683- */
5684-void candl_dependence_print_scop(FILE* input, FILE* output,
5685- CandlDependence* dependence)
5686-{
5687- scoplib_scop_p scop;
5688-
5689- /* Go to the beginning of the file. */
5690- rewind(input);
5691-
5692- /* Re-read the options tags. */
5693- scop = scoplib_scop_read(input);
5694-
5695- /* Embed the dependences in the scop option tag. */
5696- candl_dependence_update_scop_with_deps(scop, dependence);
5697-
5698- /* Dump the .scop. */
5699- scoplib_scop_print_dot_scop(output, scop);
5700-}
5701-#endif
5702-
5703-
5704-/******************************************************************************
5705- * Memory deallocation function *
5706- ******************************************************************************/
5707-
5708-
5709-/* candl_dependence_free function:
5710- * This function frees the allocated memory for a CandlDependence structure.
5711- * - 18/09/2003: first version.
5712- */
5713-void candl_dependence_free(candl_dependence_p dependence)
5714-{
5715- candl_dependence_p next;
5716-
5717- while (dependence != NULL)
5718- {
5719- next = dependence->next;
5720- candl_matrix_free(dependence->domain);
5721- free(dependence);
5722- dependence = next;
5723- }
5724-}
5725-
5726-
5727-/******************************************************************************
5728- * Processing functions *
5729- ******************************************************************************/
5730-
5731-
5732-/**
5733- * candl_dependence_malloc function:
5734- * This function allocates the memory space for a CandlDependence structure and
5735- * sets its fields with default values. Then it returns a pointer to the
5736- * allocated space.
5737- * - 07/12/2005: first version.
5738- */
5739-candl_dependence_p candl_dependence_malloc()
5740-{
5741- candl_dependence_p dependence;
5742-
5743- /* Memory allocation for the CandlDependence structure. */
5744- dependence = (candl_dependence_p) malloc(sizeof(CandlDependence));
5745- if (dependence == NULL)
5746- CANDL_FAIL(" Error: memory overflow");
5747-
5748- /* We set the various fields with default values. */
5749- dependence->source = NULL;
5750- dependence->target = NULL;
5751- dependence->depth = CANDL_UNSET;
5752- dependence->type = CANDL_UNSET;
5753- dependence->ref_source = CANDL_UNSET;
5754- dependence->ref_target = CANDL_UNSET;
5755- dependence->domain = NULL;
5756- dependence->next = NULL;
5757- dependence->usr = NULL;
5758-
5759- return dependence;
5760-}
5761-
5762-
5763-/**
5764- * candl_dependence_add function:
5765- * This function adds a CandlDependence structure (dependence) at a given place
5766- * (now) of a NULL terminated list of CandlDependence structures. The beginning
5767- * of this list is (start). This function updates (now) to the end of the loop
5768- * list (loop), and updates (start) if the added element is the first one -that
5769- * is when (start) is NULL-.
5770- * - 18/09/2003: first version.
5771- */
5772-void candl_dependence_add(candl_dependence_p* start,
5773- candl_dependence_p* now,
5774- candl_dependence_p dependence)
5775-{
5776- if (dependence != NULL)
5777- {
5778- if (*start == NULL)
5779- {
5780- *start = dependence;
5781- *now = *start;
5782- }
5783- else
5784- {
5785- (*now)->next = dependence;
5786- *now = (*now)->next;
5787- }
5788-
5789- while ((*now)->next != NULL)
5790- *now = (*now)->next;
5791+ }
5792+ if (iter == NULL) {
5793+ fprintf(stderr, "[Candl] Can't find the %dth label\n", dep->label_source);
5794+ exit(1);
5795+ }
5796+
5797+ /* target statement */
5798+ iter = scop->statement;
5799+ for (; iter != NULL ; iter = iter->next) {
5800+ usr = iter->usr;
5801+ if (usr->label == dep->label_target) {
5802+ dep->stmt_target_ptr = iter;
5803+ break;
5804 }
5805+ }
5806+ if (iter == NULL) {
5807+ fprintf(stderr, "[Candl] Can't find the %dth label\n", dep->label_target);
5808+ exit(1);
5809+ }
5810+
5811+ array_s = candl_dependence_get_relation_ref_source_in_dep(dep);
5812+ if (array_s == NULL) {
5813+ fprintf(stderr, "[Candl] Can't find the %dth access of the statement :\n",
5814+ dep->ref_source);
5815+ osl_statement_dump(stderr, dep->stmt_source_ptr);
5816+ exit(1);
5817+ }
5818+
5819+ array_t = candl_dependence_get_relation_ref_source_in_dep(dep);
5820+ if (array_t == NULL) {
5821+ fprintf(stderr, "[Candl] Can't find the %dth access of the statement :\n",
5822+ dep->ref_target);
5823+ osl_statement_dump(stderr, dep->stmt_target_ptr);
5824+ exit(1);
5825+ }
5826+
5827+ dep->source_nb_output_dims_domain = dep->stmt_source_ptr->domain->nb_output_dims;
5828+ dep->source_nb_output_dims_access = array_s->nb_output_dims;
5829+
5830+ dep->target_nb_output_dims_domain = dep->stmt_target_ptr->domain->nb_output_dims;
5831+ dep->target_nb_output_dims_access = array_t->nb_output_dims;
5832+
5833+ dep->source_nb_local_dims_domain = dep->stmt_source_ptr->domain->nb_local_dims;
5834+ dep->source_nb_local_dims_access = array_s->nb_local_dims;
5835+ dep->target_nb_local_dims_domain = dep->stmt_target_ptr->domain->nb_local_dims;
5836+ dep->target_nb_local_dims_access = array_t->nb_local_dims;
5837 }
5838
5839
5840 /**
5841 * GCD computation.
5842 */
5843-static
5844-int
5845-candl_dependence_gcd(int a, int b)
5846-{
5847+static int candl_dependence_gcd(int a, int b) {
5848 int z = 1;
5849
5850 if (a < 0)
5851@@ -870,19 +323,17 @@ candl_dependence_gcd(int a, int b)
5852 return b;
5853 if (b == 0)
5854 return a;
5855- if (b > a)
5856- {
5857- int temp = a;
5858- a = b;
5859- b = temp;
5860- }
5861+ if (b > a) {
5862+ int temp = a;
5863+ a = b;
5864+ b = temp;
5865+ }
5866
5867- while (z != 0)
5868- {
5869- z = a % b;
5870- a = b;
5871- b = z;
5872- }
5873+ while (z != 0) {
5874+ z = a % b;
5875+ a = b;
5876+ b = z;
5877+ }
5878
5879 return a;
5880 }
5881@@ -891,9 +342,7 @@ candl_dependence_gcd(int a, int b)
5882 *
5883 *
5884 */
5885-static
5886-int candl_dependence_gcd_test_context (CandlMatrix* system, int id)
5887-{
5888+static int candl_dependence_gcd_test_context(osl_relation_p system, int id) {
5889 /* FIXME: implement me! */
5890
5891 return 1;
5892@@ -915,16 +364,18 @@ int candl_dependence_gcd_test_context (CandlMatrix* system, int id)
5893 * are also performed before the actual GCD test.
5894 *
5895 */
5896-int candl_dependence_gcd_test(CandlStatement* source,
5897- CandlStatement* target,
5898- CandlMatrix* system,
5899- int level)
5900-{
5901+int candl_dependence_gcd_test(osl_statement_p source,
5902+ osl_statement_p target,
5903+ osl_relation_p system,
5904+ int level) {
5905 int i;
5906 int gcd;
5907 int id;
5908 int value;
5909 int null_iter, null_param, null_cst, pos_iter, neg_iter;
5910+ int precision = source->domain->precision;
5911+ candl_statement_usr_p s_usr = source->usr;
5912+ candl_statement_usr_p t_usr = target->usr;
5913
5914 /* Check that the precedence constraint, if any, is not strict in a
5915 self-dependence. */
5916@@ -937,59 +388,63 @@ int candl_dependence_gcd_test(CandlStatement* source,
5917 /* strict_pred = 0; */
5918
5919 /* Inspect the array access function equalities. */
5920- for (id = source->domain->NbRows + target->domain->NbRows;
5921- id < system->NbRows && CANDL_get_si(system->p[id][0]) == 0; ++id)
5922- {
5923- /* Inspect which parts of the access function equality are null,
5924- positive or negative. */
5925- null_iter = null_param = null_cst = pos_iter = neg_iter = 0;
5926- for (i = 1; i < source->depth + target->depth + 1 &&
5927- CANDL_get_si(system->p[id][i]) == 0; ++i)
5928- ;
5929- if (i == source->depth + target->depth + 1)
5930- null_iter = 1;
5931- else
5932- for (pos_iter = 1, neg_iter = 1;
5933- i < source->depth + target->depth + 1; ++i)
5934- {
5935- if (CANDL_get_si(system->p[id][i]) < 0)
5936- pos_iter = 0;
5937- else if (CANDL_get_si(system->p[id][i]) > 0)
5938- neg_iter = 0;
5939- }
5940- for (; i < system->NbColumns - 1 && CANDL_get_si(system->p[id][i]) == 0;
5941- ++i)
5942- ;
5943- if (i == system->NbColumns - 1)
5944- null_param = 1;
5945- null_cst = ! CANDL_get_si(system->p[id][system->NbColumns - 1]);
5946-
5947- /* Some useful ZIV/SIV/MIV tests. */
5948- if (null_iter && null_param && !null_cst)
5949- return 0;
5950- if (null_iter)
5951- if (! candl_dependence_gcd_test_context (system, id))
5952- return 0;
5953- if (null_cst || !null_param)
5954- continue;
5955-/* FIXME: implement the loop bound check. */
5956-/* /\* A clever test on access bounds. *\/ */
5957-/* if (null_param && pos_iter && */
5958-/* CANDL_get_si(system->p[id][system->NbColumns - 1]) > 0) */
5959-/* return 0; */
5960-/* if (null_param && neg_iter && */
5961-/* CANDL_get_si(system->p[id][system->NbColumns - 1]) < 0) */
5962-/* return 0; */
5963-
5964- /* Compute GCD test for the array access equality. */
5965- for (i = 1, gcd = CANDL_get_si(system->p[id][i]);
5966- i < source->depth + target->depth; ++i)
5967- gcd = candl_dependence_gcd(gcd, CANDL_get_si(system->p[id][i + 1]));
5968- value = CANDL_get_si(system->p[id][system->NbColumns - 1]);
5969- value = value < 0 ? -value : value;
5970- if ((gcd == 0 && value != 0) || value % gcd)
5971- return 0;
5972- }
5973+ for (id = source->domain->nb_rows + target->domain->nb_rows;
5974+ id < system->nb_rows &&
5975+ osl_int_zero(precision, system->m[id][0]);
5976+ ++id) {
5977+ /* Inspect which parts of the access function equality are null,
5978+ positive or negative. */
5979+ null_iter = null_param = null_cst = pos_iter = neg_iter = 0;
5980+
5981+ for (i = 1; i < s_usr->depth + t_usr->depth + 1 &&
5982+ osl_int_zero(precision, system->m[id][i]); ++i)
5983+ ;
5984+
5985+ if (i == s_usr->depth + t_usr->depth + 1)
5986+ null_iter = 1;
5987+ else
5988+ for (pos_iter = 1, neg_iter = 1;
5989+ i < s_usr->depth + t_usr->depth + 1; ++i) {
5990+ if (osl_int_neg(precision, system->m[id][i]))
5991+ pos_iter = 0;
5992+ else if (osl_int_pos(precision, system->m[id][i]))
5993+ neg_iter = 0;
5994+ }
5995+ for (; i < system->nb_columns - 1 &&
5996+ osl_int_zero(precision, system->m[id][i]) == 0; ++i)
5997+ ;
5998+ if (i == system->nb_columns - 1)
5999+ null_param = 1;
6000+ null_cst = osl_int_zero(precision, system->m[id][system->nb_columns - 1]);
6001+
6002+ /* Some useful ZIV/SIV/MIV tests. */
6003+ if (null_iter && null_param && !null_cst)
6004+ return 0;
6005+ if (null_iter)
6006+ if (! candl_dependence_gcd_test_context(system, id))
6007+ return 0;
6008+ if (null_cst || !null_param)
6009+ continue;
6010+ /* FIXME: implement the loop bound check. */
6011+ /* /\* A clever test on access bounds. *\/ */
6012+ /* if (null_param && pos_iter && */
6013+ /* CANDL_get_si(system->p[id][system->NbColumns - 1]) > 0) */
6014+ /* return 0; */
6015+ /* if (null_param && neg_iter && */
6016+ /* CANDL_get_si(system->p[id][system->NbColumns - 1]) < 0) */
6017+ /* return 0; */
6018+
6019+ /* Compute GCD test for the array access equality. */
6020+ for (i = 1, gcd = osl_int_get_si(precision, system->m[id][i]);
6021+ i < s_usr->depth + t_usr->depth; ++i)
6022+ gcd = candl_dependence_gcd(gcd,
6023+ osl_int_get_si(precision, system->m[id][i + 1]));
6024+
6025+ value = osl_int_get_si(precision, system->m[id][system->nb_columns - 1]);
6026+ value = value < 0 ? -value : value;
6027+ if ((gcd == 0 && value != 0) || value % gcd)
6028+ return 0;
6029+ }
6030
6031 return 1;
6032 }
6033@@ -1006,135 +461,243 @@ int candl_dependence_gcd_test(CandlStatement* source,
6034 * See the [bastoul and Feautrier, PPL 2005] paper for details !
6035 * - source is the source iteration domain,
6036 * - target is the target iteration domain,
6037- * - array_s is the array list for the source,
6038- * - array_t is the array list for the target,
6039- * - ref_s is the position of the source reference in array_s,
6040- * - ref_s is the position of the target reference in array_t,
6041+ * - array_s is the access array for the source,
6042+ * - array_t is the access array for the target,
6043 * - depth is the dependence depth,
6044 * - before is 1 if the source is textually before the target, 0 otherwise,
6045- * - nb_par is the number of parameters.
6046 ***
6047 * - 13/12/2005: first version (extracted from candl_dependence_system).
6048 * - 23/02/2006: a stupid bug corrected in the subscript equality.
6049 * - 07/04/2007: fix the precedence condition to respect C. Bastoul PhD thesis
6050 */
6051-static
6052-CandlMatrix * candl_dependence_build_system(source, target, array_s, array_t,
6053- ref_s, ref_t, depth, before, nb_par)
6054-CandlStatement * source, * target;
6055-CandlMatrix * array_s, * array_t ;
6056-int ref_s, ref_t, depth, before, nb_par ;
6057-{ int i, j, nb_rows, nb_columns, nb_dimensions, constraint, s_dims, t_dims ;
6058- CandlMatrix * system ;
6059- Entier temp ;
6060-
6061- CANDL_init(temp) ;
6062-
6063- /* We calculate the number of dimensions of the considered array. */
6064- nb_dimensions = 1;
6065- while (((ref_s + nb_dimensions + 1) <= array_s->NbRows) &&
6066- (array_s->p[ref_s + nb_dimensions][0] == 0))
6067- nb_dimensions ++ ;
6068-
6069- /* The number of dimensions of the source and target domains. */
6070- s_dims = source->domain->NbColumns - nb_par - 2 ;
6071- t_dims = target->domain->NbColumns - nb_par - 2 ;
6072-
6073- /* The number of rows of the system is:
6074- * - the number of constraints of the source iteration domain +
6075- * - the number of constraints of the target iteration domain +
6076- * - the number of dimensions of the considered array (subscript equality) +
6077- * - the number of precedence constraints (equal to depth).
6078- */
6079- nb_rows = source->domain->NbRows + target->domain->NbRows +
6080- nb_dimensions + depth ;
6081-
6082- /* The number of columns of the system is:
6083- * - the number of source statement surrounding loops +
6084- * - the number of target statement surrounding loops +
6085- * - the number of parameters +
6086- * - 2 (1 for equality/inequality identifier + 1 for the constant).
6087- */
6088- nb_columns = s_dims + t_dims + nb_par + 2 ;
6089-
6090- /* We allocate memory space for the constraint system. */
6091- system = candl_matrix_malloc(nb_rows,nb_columns) ;
6092-
6093- /* Compute the maximal common depth. */
6094+static osl_dependence_p candl_dependence_build_system(
6095+ osl_statement_p source, osl_statement_p target,
6096+ osl_relation_p array_s, osl_relation_p array_t,
6097+ int depth, int before) {
6098+ osl_dependence_p dependence;
6099+ osl_relation_p system;
6100+ int i, j, k, c;
6101+ int constraint = 0;
6102+ int precision = source->domain->precision;
6103+ int nb_output_dims; // source column
6104+ int nb_input_dims; // target column
6105+ int nb_local_dims;
6106+ int nb_par;
6107+ int nb_rows, nb_columns;
6108+ int ind_source_local_domain;
6109+ int ind_source_local_access;
6110+ int ind_target_local_domain;
6111+ int ind_target_local_access;
6112+ int ind_params;
6113 int min_depth = 0;
6114- while (min_depth < source->depth && min_depth < target->depth &&
6115- source->index[min_depth] == target->index[min_depth])
6116- ++min_depth;
6117-
6118- /* We fill the constraint system (note that there is no need to put zeros
6119- * in the empty zones since candl_matrix_alloc initialized all entries to 0):
6120- */
6121-
6122- /* 1. The source iteration domain constraints. */
6123- constraint = 0 ;
6124- for (i=0;i<source->domain->NbRows;i++)
6125- { for (j=0;j<=s_dims;j++)
6126- CANDL_assign(system->p[constraint][j],source->domain->p[i][j]) ;
6127-
6128- for (j=s_dims+1;j<source->domain->NbColumns;j++)
6129- CANDL_assign(system->p[constraint][j+t_dims],source->domain->p[i][j]) ;
6130-
6131- constraint++ ;
6132+
6133+ /* Create a new dependence structure */
6134+ dependence = osl_dependence_malloc();
6135+
6136+ /* Compute the maximal common depth. */
6137+ min_depth = CANDL_min(array_s->nb_output_dims, array_t->nb_output_dims);
6138+
6139+ /* Compute the system size */
6140+ dependence->source_nb_output_dims_domain = source->domain->nb_output_dims;
6141+ dependence->source_nb_output_dims_access = array_s->nb_output_dims;
6142+
6143+ dependence->target_nb_output_dims_domain = target->domain->nb_output_dims;
6144+ dependence->target_nb_output_dims_access = array_t->nb_output_dims;
6145+
6146+ dependence->source_nb_local_dims_domain = source->domain->nb_local_dims;
6147+ dependence->source_nb_local_dims_access = array_s->nb_local_dims;
6148+ dependence->target_nb_local_dims_domain = target->domain->nb_local_dims;
6149+ dependence->target_nb_local_dims_access = array_t->nb_local_dims;
6150+
6151+ nb_par = source->domain->nb_parameters;
6152+ nb_local_dims = dependence->source_nb_local_dims_domain +
6153+ dependence->source_nb_local_dims_access +
6154+ dependence->target_nb_local_dims_domain +
6155+ dependence->target_nb_local_dims_access;
6156+ nb_output_dims = dependence->source_nb_output_dims_domain +
6157+ dependence->source_nb_output_dims_access;
6158+ nb_input_dims = dependence->target_nb_output_dims_domain +
6159+ dependence->target_nb_output_dims_access;
6160+
6161+ nb_columns = nb_output_dims + nb_input_dims + nb_local_dims + nb_par + 2;
6162+ nb_rows = source->domain->nb_rows + target->domain->nb_rows +
6163+ array_s->nb_rows + array_t->nb_rows +
6164+ min_depth +
6165+ depth;
6166+
6167+ system = osl_relation_pmalloc(precision, nb_rows, nb_columns);
6168+
6169+ /* Compute some indexes */
6170+ ind_source_local_domain = 1 + nb_output_dims + nb_input_dims;
6171+ ind_source_local_access = ind_source_local_domain + dependence->source_nb_local_dims_domain;
6172+ ind_target_local_domain = ind_source_local_access + dependence->source_nb_local_dims_access;
6173+ ind_target_local_access = ind_target_local_domain + dependence->target_nb_local_dims_domain;
6174+ ind_params = ind_target_local_access + dependence->target_nb_local_dims_access;
6175+
6176+ /* 1. Copy the source domain */
6177+ for (i = 0 ; i < source->domain->nb_rows ; i++) {
6178+ /* eq/in */
6179+ osl_int_assign(precision,
6180+ &system->m[constraint][0], source->domain->m[i][0]);
6181+ /* output dims */
6182+ k = 1;
6183+ j = 1;
6184+ for (c = source->domain->nb_output_dims ; c > 0 ; c--, k++, j++)
6185+ osl_int_assign(precision,
6186+ &system->m[constraint][k], source->domain->m[i][j]);
6187+ /* local dims (no input in domain, so j is the same) */
6188+ k = ind_source_local_domain;
6189+ for (c = source->domain->nb_local_dims ; c > 0 ; c--, k++, j++)
6190+ osl_int_assign(precision,
6191+ &system->m[constraint][k], source->domain->m[i][j]);
6192+ /* params + const */
6193+ k = ind_params;
6194+ for (c = nb_par+1 ; c > 0 ; c--, k++, j++)
6195+ osl_int_assign(precision,
6196+ &system->m[constraint][k], source->domain->m[i][j]);
6197+ constraint++;
6198 }
6199-
6200- /* 2. The target iteration domain constraints. */
6201- for (i = 0; i < target->domain->NbRows; i++)
6202- { CANDL_assign(system->p[constraint][0],target->domain->p[i][0]) ;
6203-
6204- for (j = 1; j < target->domain->NbColumns; j++)
6205- CANDL_assign(system->p[constraint][j + s_dims], target->domain->p[i][j]) ;
6206-
6207- constraint++ ;
6208+
6209+ /* 2. Copy the target domain */
6210+ for (i = 0 ; i < target->domain->nb_rows ; i++) {
6211+ /* eq/in */
6212+ osl_int_assign(precision,
6213+ &system->m[constraint][0], target->domain->m[i][0]);
6214+ /* output dims */
6215+ k = 1 + nb_output_dims;
6216+ j = 1;
6217+ for (c = target->domain->nb_output_dims ; c > 0 ; c--, k++, j++)
6218+ osl_int_assign(precision,
6219+ &system->m[constraint][k], target->domain->m[i][j]);
6220+ /* local dims (no input in domain, so j is the same) */
6221+ k = ind_target_local_domain;
6222+ for (c = target->domain->nb_local_dims ; c > 0 ; c--, k++, j++)
6223+ osl_int_assign(precision,
6224+ &system->m[constraint][k], target->domain->m[i][j]);
6225+ /* params + const */
6226+ k = ind_params;
6227+ for (c = nb_par+1 ; c > 0 ; c--, k++, j++)
6228+ osl_int_assign(precision,
6229+ &system->m[constraint][k], target->domain->m[i][j]);
6230+ constraint++;
6231 }
6232-
6233- int subeq = 0;
6234-
6235- /* 3. The equality of the subscripts. */
6236- for (i = 0; i < nb_dimensions; i++)
6237- { /* Source iterator coefficients part. */
6238- for (j = 1; j <= s_dims; j++)
6239- CANDL_assign(system->p[constraint][j], array_s->p[ref_s + i][j]) ;
6240-
6241- /* Target iterator coefficients part (negative). */
6242- for (j = 1; j <= t_dims; j++)
6243- { CANDL_oppose(temp, array_t->p[ref_t + i][j]) ;
6244- CANDL_assign(system->p[constraint][j + s_dims], temp) ;
6245+
6246+ /* 3. Copy the source access */
6247+ for (i = 0 ; i < array_s->nb_rows ; i++) {
6248+ /* eq/in */
6249+ osl_int_assign(precision,
6250+ &system->m[constraint][0], array_s->m[i][0]);
6251+ /* output dims */
6252+ k = 1 + source->domain->nb_output_dims;
6253+ j = 1;
6254+ for (c = array_s->nb_output_dims ; c > 0 ; c--, k++, j++)
6255+ osl_int_assign(precision,
6256+ &system->m[constraint][k], array_s->m[i][j]);
6257+ /* link input dims access to the output dims domain */
6258+ k = 1;
6259+ for (c = array_s->nb_input_dims ; c > 0 ; c--, k++, j++)
6260+ osl_int_assign(precision,
6261+ &system->m[constraint][k], array_s->m[i][j]);
6262+ /* local dims */
6263+ k = ind_source_local_access;
6264+ for (c = array_s->nb_local_dims ; c > 0 ; c--, k++, j++)
6265+ osl_int_assign(precision,
6266+ &system->m[constraint][k], array_s->m[i][j]);
6267+ /* params + const */
6268+ k = ind_params;
6269+ for (c = nb_par+1 ; c > 0 ; c--, k++, j++)
6270+ osl_int_assign(precision,
6271+ &system->m[constraint][k], array_s->m[i][j]);
6272+
6273+ constraint++;
6274+ }
6275+
6276+ /* 4. Copy the target access */
6277+ for (i = 0 ; i < array_t->nb_rows ; i++) {
6278+ /* eq/in */
6279+ osl_int_assign(precision,
6280+ &system->m[constraint][0], array_t->m[i][0]);
6281+ /* output dims */
6282+ k = 1 + nb_output_dims + target->domain->nb_output_dims;
6283+ j = 1;
6284+ for (c = array_t->nb_output_dims ; c > 0 ; c--, k++, j++) {
6285+ osl_int_assign(precision,
6286+ &system->m[constraint][k], array_t->m[i][j]);
6287+ osl_int_oppose(precision,
6288+ &system->m[constraint][k], system->m[constraint][k]);
6289 }
6290-
6291- /* Parameters and constant coefficients part. */
6292- for (j = 1; j <= nb_par + 1; j++)
6293- CANDL_subtract(system->p[constraint][j + s_dims + t_dims],
6294- array_s->p[ref_s + i][j + s_dims],
6295- array_t->p[ref_t + i][j + t_dims]) ;
6296- constraint++ ;
6297- subeq++;
6298+ /* link input dims access to the output dims domain */
6299+ k = 1 + nb_output_dims;
6300+ for (c = array_t->nb_input_dims ; c > 0 ; c--, k++, j++) {
6301+ osl_int_assign(precision,
6302+ &system->m[constraint][k], array_t->m[i][j]);
6303+ osl_int_oppose(precision,
6304+ &system->m[constraint][k], system->m[constraint][k]);
6305+ }
6306+ /* local dims */
6307+ k = ind_target_local_access;
6308+ for (c = array_t->nb_local_dims ; c > 0 ; c--, k++, j++) {
6309+ osl_int_assign(precision,
6310+ &system->m[constraint][k], array_t->m[i][j]);
6311+ osl_int_oppose(precision,
6312+ &system->m[constraint][k], system->m[constraint][k]);
6313+ }
6314+ /* params + const */
6315+ k = ind_params;
6316+ for (c = nb_par+1 ; c > 0 ; c--, k++, j++) {
6317+ osl_int_assign(precision,
6318+ &system->m[constraint][k], array_t->m[i][j]);
6319+ osl_int_oppose(precision,
6320+ &system->m[constraint][k], system->m[constraint][k]);
6321+ }
6322+ constraint++;
6323 }
6324-
6325- /* 4. The precedence constraints (their number is equal to depth). */
6326- for (i = 0; i < depth; i++)
6327- { /* i = i' for all dimension less than depth. */
6328- CANDL_set_si(system->p[constraint][i + 1], -1) ;
6329- CANDL_set_si(system->p[constraint][s_dims + i + 1], 1) ;
6330- if (i == depth - 1)
6331- {
6332- /* i <= i' at dimension depth if source is textually before target. */
6333- CANDL_set_si(system->p[constraint][0], 1) ;
6334- /* If source is textually after target, this is obviously i < i'. */
6335- if (before || depth < min_depth)
6336- //if (before)
6337- CANDL_set_si(system->p[constraint][nb_columns - 1], -1);
6338- }
6339-
6340- constraint++ ;
6341+
6342+
6343+ /* 5. Set the equality between the output access */
6344+ /* Note here that the equality between the 2 Arr are necessarily equal */
6345+ k = 1 + source->domain->nb_output_dims;
6346+ j = 1 + nb_output_dims + target->domain->nb_output_dims;
6347+ for (i = 0 ; i < min_depth ; i++, k++, j++) {
6348+ osl_int_set_si(precision, &system->m[constraint][k], -1);
6349+ osl_int_set_si(precision, &system->m[constraint][j], 1);
6350+ constraint++;
6351 }
6352+
6353+ /* 6. The precedence constraints */
6354+ int min_dim = 0;
6355+ while (min_dim < ((candl_statement_usr_p)source->usr)->depth &&
6356+ min_dim < ((candl_statement_usr_p)target->usr)->depth &&
6357+ ((candl_statement_usr_p)source->usr)->index[min_dim] ==
6358+ ((candl_statement_usr_p)target->usr)->index[min_dim])
6359+ ++min_dim;
6360+
6361+ k = 1;
6362+ j = 1 + nb_output_dims;
6363+ for (i = 0; i < depth; i++, k++, j++) {
6364+ /* i = i' for all dimension less than depth. */
6365+ osl_int_set_si(precision, &system->m[constraint][k], -1);
6366+ osl_int_set_si(precision, &system->m[constraint][j], 1);
6367+ if (i == depth - 1) {
6368+ /* i <= i' at dimension depth if source is textually before target. */
6369+ osl_int_set_si(precision, &system->m[constraint][0], 1);
6370+ /* If source is textually after target, this is obviously i < i'. */
6371+ if (before || depth < min_dim) // sub 1 for the Arr dim
6372+ osl_int_set_si(precision, &system->m[constraint][nb_columns - 1], -1);
6373+ }
6374
6375- CANDL_clear(temp) ;
6376- return system ;
6377+ constraint++;
6378+ }
6379+
6380+ system->nb_output_dims = nb_output_dims;
6381+ system->nb_input_dims = nb_input_dims;
6382+ system->nb_parameters = nb_par;
6383+ system->nb_local_dims = nb_local_dims;
6384+ system->type = OSL_UNDEFINED;
6385+
6386+ dependence->domain = system;
6387+
6388+ return dependence;
6389 }
6390
6391
6392@@ -1157,49 +720,53 @@ int ref_s, ref_t, depth, before, nb_par ;
6393 * - 18/09/2003: first version.
6394 * - 09/12/2005: few corrections and polishing.
6395 */
6396-candl_dependence_p candl_dependence_system(CandlStatement* source,
6397- CandlStatement* target,
6398- CandlMatrix* context,
6399- CandlMatrix* array_s,
6400- CandlMatrix* array_t,
6401- int ref_s, int ref_t,
6402- int type, int depth)
6403-{
6404- candl_dependence_p dependence = NULL;
6405- CandlMatrix * system;
6406+osl_dependence_p candl_dependence_system(osl_statement_p source,
6407+ osl_statement_p target,
6408+ osl_relation_p context,
6409+ osl_relation_p array_s,
6410+ osl_relation_p array_t,
6411+ int ref_s, int ref_t,
6412+ int type, int depth) {
6413+ candl_statement_usr_p s_usr = source->usr;
6414+ candl_statement_usr_p t_usr = target->usr;
6415+ osl_dependence_p dependence = NULL;
6416
6417 /* First, a trivial case: for two different statements at depth 0, there is
6418 * a dependence only if the source is textually before the target.
6419 */
6420- if ((source != target) && (depth == 0) && (source->label > target->label))
6421+ if ((source != target) && (depth == 0) &&
6422+ (s_usr->label > t_usr->label))
6423 return NULL;
6424-
6425+
6426 /* We build the system of constraints. */
6427- system = candl_dependence_build_system(source, target,
6428- array_s, array_t, ref_s, ref_t,
6429- depth,
6430- (source->label >= target->label),
6431- context->NbColumns-2);
6432+ dependence = candl_dependence_build_system(source, target,
6433+ array_s, array_t,
6434+ depth,
6435+ (s_usr->label >=
6436+ t_usr->label));
6437
6438 /* We start by simple SIV/ZIV/GCD tests. */
6439- if (! candl_dependence_gcd_test(source, target, system, depth))
6440+ if (!candl_dependence_gcd_test(source, target, dependence->domain, depth)) {
6441+ osl_dependence_free(dependence);
6442 return NULL;
6443+ }
6444
6445- if (pip_has_rational_point (system, context, 1))
6446- {
6447- dependence = candl_dependence_malloc();
6448-
6449- /* We set the various fields with corresponding values. */
6450- dependence->type = type;
6451- dependence->depth = depth;
6452- dependence->source = source;
6453- dependence->target = target;
6454- dependence->ref_source = ref_s;
6455- dependence->ref_target = ref_t;
6456- dependence->domain = system;
6457- }
6458- else
6459- candl_matrix_free(system);
6460+ if (pip_has_rational_point(dependence->domain, context, 1)) {
6461+ /* We set the various fields with corresponding values. */
6462+ dependence->ref_source = ref_s;
6463+ dependence->ref_target = ref_t;
6464+ dependence->label_source = ((candl_statement_usr_p)source->usr)->label;
6465+ dependence->label_target = ((candl_statement_usr_p)target->usr)->label;
6466+ dependence->type = type;
6467+ dependence->depth = depth;
6468+ dependence->stmt_source_ptr = source;
6469+ dependence->stmt_target_ptr = target;
6470+ dependence->ref_source_access_ptr = array_s;
6471+ dependence->ref_target_access_ptr = array_t;
6472+ } else {
6473+ osl_dependence_free(dependence);
6474+ dependence = NULL;
6475+ }
6476
6477 return dependence;
6478 }
6479@@ -1215,20 +782,25 @@ candl_dependence_p candl_dependence_system(CandlStatement* source,
6480 * - 07/12/2005: (debug) correction of depth bounds.
6481 * - 09/12/2005: We may take commutativity into consideration.
6482 */
6483-candl_dependence_p candl_dependence_between(CandlStatement* source,
6484- CandlStatement* target,
6485- CandlMatrix* context,
6486- CandlOptions* options)
6487-{
6488- int i, j, k, min_depth, max_depth;
6489- candl_dependence_p new;
6490- candl_dependence_p dependence = NULL;
6491- candl_dependence_p now;
6492-
6493+osl_dependence_p candl_dependence_between(osl_statement_p source,
6494+ osl_statement_p target,
6495+ osl_relation_p context,
6496+ candl_options_p options) {
6497+ osl_dependence_p new;
6498+ osl_dependence_p dependence = NULL;
6499+ osl_dependence_p now;
6500+ osl_relation_list_p access_src, access_targ;
6501+ osl_relation_p elt_src, elt_targ;
6502+ candl_statement_usr_p s_usr = source->usr;
6503+ candl_statement_usr_p t_usr = target->usr;
6504+ int i, min_depth, max_depth;
6505+ int src_id, targ_id;
6506+ int ref_s, ref_t;
6507+
6508 /* If the statements commute and the user asks to use this information to
6509 * simplify the dependence graph, we return no dependences.
6510 */
6511- if (options->commute && candl_statement_commute(source, target))
6512+ if (options->commute && candl_util_statement_commute(source, target))
6513 return NULL;
6514
6515 /* In the case of a self-dependence, the dependence depth can be as low as 1
6516@@ -1237,155 +809,209 @@ candl_dependence_p candl_dependence_between(CandlStatement* source,
6517 * In the case of different statements, the dependence depth can be as low
6518 * as 0 and as high as the number of shared loops.
6519 */
6520- if (source == target)
6521- {
6522- min_depth = 1;
6523- max_depth = source->depth;
6524- }
6525- else
6526- {
6527- /* Depth 0 is for statements that don't share any loop. */
6528- min_depth = (source->index[0] == target->index[0]) ? 1 : 0;
6529-
6530- max_depth = 0;
6531- while ((max_depth < source->depth) &&
6532- (max_depth < target->depth) &&
6533- (source->index[max_depth] == target->index[max_depth]))
6534- max_depth++;
6535- }
6536-
6537- /* Flow and output-dependences analysis. */
6538- for (j = 0; j < source->written->NbRows; j++)
6539- if (CANDL_notzero_p(source->written->p[j][0]))
6540- {
6541- /* Flow-dependences analysis. */
6542- if (options->raw)
6543- for (k = 0; k < target->read->NbRows; k++)
6544- if (CANDL_eq(target->read->p[k][0], source->written->p[j][0]))
6545- for (i = min_depth; i <= max_depth; i++)
6546- {
6547- new = candl_dependence_system(source, target, context,
6548- source->written, target->read,
6549- j, k, CANDL_RAW, i);
6550- candl_dependence_add(&dependence, &now, new);
6551- }
6552- /* Output-dependences analysis. */
6553- if (options->waw)
6554- for (k = 0; k < target->written->NbRows; k++)
6555- if (CANDL_eq(target->written->p[k][0], source->written->p[j][0]))
6556- for (i = min_depth; i <= max_depth; i++)
6557- {
6558- new = candl_dependence_system(source, target, context,
6559- source->written,
6560- target->written, j, k,
6561- CANDL_WAW, i);
6562- candl_dependence_add(&dependence, &now, new);
6563- }
6564- }
6565-
6566- /* Anti and input-dependences analysis. */
6567- for (j = 0; j < source->read->NbRows; j++)
6568- if (source->read->p[j][0] != 0)
6569- {
6570- /* Anti-dependences analysis. */
6571- if (options->war)
6572- for (k = 0; k < target->written->NbRows; k++)
6573- if (CANDL_eq(target->written->p[k][0], source->read->p[j][0]))
6574- for (i = min_depth; i <= max_depth; i++)
6575- {
6576- new = candl_dependence_system(source, target, context,
6577- source->read, target->written,
6578- j, k, CANDL_WAR, i);
6579- candl_dependence_add(&dependence, &now, new);
6580- }
6581- /* Input-dependences analysis. */
6582- if (options->rar)
6583- for (k = 0; k < target->read->NbRows; k++)
6584- if (CANDL_eq(target->read->p[k][0], source->read->p[j][0]))
6585- for (i = min_depth; i <= max_depth; i++)
6586- {
6587- new = candl_dependence_system(source, target, context,
6588- source->read, target->read,
6589- j, k, CANDL_RAR, i);
6590- candl_dependence_add(&dependence, &now, new);
6591- }
6592- }
6593+ if (source == target) {
6594+ min_depth = 1;
6595+ max_depth = s_usr->depth;
6596+ } else {
6597+ /* Depth 0 is for statements that don't share any loop. */
6598+ if (s_usr->depth > 0 && t_usr->depth > 0)
6599+ min_depth = (s_usr->index[0] == t_usr->index[0]) ? 1 : 0;
6600+ else
6601+ min_depth = 0;
6602
6603+ max_depth = 0;
6604+ while ((max_depth < s_usr->depth) &&
6605+ (max_depth < t_usr->depth) &&
6606+ (s_usr->index[max_depth] == t_usr->index[max_depth]))
6607+ max_depth++;
6608+ }
6609+
6610+ ref_s = 0;
6611+ access_src = source->access;
6612+
6613+ for (; access_src != NULL; access_src = access_src->next, ref_s++) {
6614+ elt_src = access_src->elt;
6615+ src_id = osl_relation_get_array_id(elt_src);
6616+
6617+ switch(elt_src->type) {
6618+
6619+ /* Anti and input-dependences analysis. */
6620+ case OSL_TYPE_READ: /* source READ */
6621+ if (!options->war && !options->rar)
6622+ break;
6623+ access_targ = target->access;
6624+ ref_t = 0;
6625+ for (; access_targ != NULL; access_targ = access_targ->next, ref_t++) {
6626+ elt_targ = access_targ->elt;
6627+ targ_id = osl_relation_get_array_id(elt_targ);
6628+
6629+ /* Anti-dependences analysis. */
6630+ if (elt_targ->type != OSL_TYPE_READ) { /* target WRITE | MAY_WRITE */
6631+ if (options->war && src_id == targ_id) {
6632+ for (i = min_depth; i <= max_depth; i++) {
6633+ new = candl_dependence_system(source, target, context,
6634+ elt_src, elt_targ,
6635+ ref_s, ref_t,
6636+ OSL_DEPENDENCE_WAR, i);
6637+ osl_dependence_add(&dependence, &now, new);
6638+ }
6639+ }
6640+ }
6641+ /* Input-dependences analysis. */
6642+ else { /* target READ */
6643+ if (options->rar && src_id == targ_id) {
6644+ for (i = min_depth; i <= max_depth; i++) {
6645+ new = candl_dependence_system(source, target, context,
6646+ elt_src, elt_targ,
6647+ ref_s, ref_t,
6648+ OSL_DEPENDENCE_RAR, i);
6649+ osl_dependence_add(&dependence, &now, new);
6650+ }
6651+ }
6652+ }
6653+ }
6654+ break;
6655+
6656+ default: /* source WRITE | MAY-WRITE */
6657+ if (!options->raw && !options->waw)
6658+ break;
6659+ access_targ = target->access;
6660+ ref_t = 0;
6661+ for (; access_targ != NULL; access_targ = access_targ->next, ref_t++) {
6662+ elt_targ = access_targ->elt;
6663+ targ_id = osl_relation_get_array_id(elt_targ);
6664+
6665+ /* Anti-dependences analysis. */
6666+ if (elt_targ->type != OSL_TYPE_READ) { /* target WRITE | MAY_WRITE */
6667+ if (options->waw && src_id == targ_id) {
6668+ for (i = min_depth; i <= max_depth; i++) {
6669+ new = candl_dependence_system(source, target, context,
6670+ elt_src, elt_targ,
6671+ ref_s, ref_t,
6672+ OSL_DEPENDENCE_WAW, i);
6673+ osl_dependence_add(&dependence, &now, new);
6674+ }
6675+ }
6676+ }
6677+ /* Input-dependences analysis. */
6678+ else { /* target READ */
6679+ if (options->raw && src_id == targ_id) {
6680+ for (i = min_depth; i <= max_depth; i++) {
6681+ new = candl_dependence_system(source, target, context,
6682+ elt_src, elt_targ,
6683+ ref_s, ref_t,
6684+ OSL_DEPENDENCE_RAW, i);
6685+ osl_dependence_add(&dependence, &now, new);
6686+ }
6687+ }
6688+ }
6689+ }
6690+ break;
6691+ }
6692+ }
6693+
6694 return dependence;
6695 }
6696
6697
6698-
6699-
6700-
6701 /**
6702 * candl_dependence function:
6703- * this function builds the dependence graph of a program (program)
6704+ * this function builds the dependence graph of a scop
6705 * according to some user options (options).
6706 * - 18/09/2003: first version.
6707 */
6708-candl_dependence_p candl_dependence(candl_program_p program,
6709- CandlOptions* options)
6710-{
6711- int i, j;
6712- candl_dependence_p dependence = NULL;
6713- candl_dependence_p new = NULL;
6714- candl_dependence_p now;
6715- CandlStatement ** statement;
6716- CandlMatrix * context;
6717-
6718- statement = program->statement;
6719- context = program->context;
6720+osl_dependence_p candl_dependence(osl_scop_p scop, candl_options_p options) {
6721+ if (scop == NULL) { return NULL; }
6722+
6723+ osl_dependence_p dependence = NULL;
6724+ osl_dependence_p new = NULL;
6725+ osl_dependence_p now;
6726+ osl_statement_p stmt_i, stmt_j;
6727+ osl_relation_p context = scop->context;
6728+
6729 if (options->scalar_privatization || options->scalar_expansion)
6730- candl_dependence_analyze_scalars (program, options);
6731-
6732- for (i = 0; i < program->nb_statements; i++)
6733- { /* We add self dependence. */
6734- /* S->S */
6735- new = candl_dependence_between(statement[i], statement[i],
6736- context, options);
6737- candl_dependence_add(&dependence, &now, new);
6738-
6739- for (j = i + 1; j < program->nb_statements; j++)
6740- { /* And dependences with other statements. */
6741- /* S1->S2 */
6742- new = candl_dependence_between(statement[i], statement[j],
6743- context, options);
6744- candl_dependence_add(&dependence, &now, new);
6745-
6746- /* S2->S1 */
6747- new = candl_dependence_between(statement[j], statement[i],
6748- context, options);
6749- candl_dependence_add(&dependence, &now, new);
6750- }
6751+ candl_dependence_analyze_scalars(scop, options);
6752+
6753+ stmt_i = scop->statement;
6754+ for (; stmt_i != NULL; stmt_i = stmt_i->next) {
6755+ /* We add self dependence. */
6756+ /* S->S */
6757+ new = candl_dependence_between(stmt_i, stmt_i, context, options);
6758+ osl_dependence_add(&dependence, &now, new);
6759+
6760+ stmt_j = stmt_i->next;
6761+ for (; stmt_j != NULL; stmt_j = stmt_j ->next) {
6762+ /* And dependences with other statements. */
6763+ /* S1->S2 */
6764+ new = candl_dependence_between(stmt_i, stmt_j, context, options);
6765+ osl_dependence_add(&dependence, &now, new);
6766+
6767+ /* S2->S1 */
6768+ new = candl_dependence_between(stmt_j, stmt_i, context, options);
6769+ osl_dependence_add(&dependence, &now, new);
6770 }
6771-
6772+ }
6773+
6774 /* If scalar analysis is called, remove some useless dependences. */
6775 /* LNP: This is subsubmed by the updated prune-with-privatization function. */
6776- /* if (options->scalar_privatization || options->scalar_expansion || */
6777- /* options->scalar_renaming) */
6778- /* candl_dependence_prune_scalar_waw (program, options, &dependence); */
6779+ /* if (options->scalar_privatization || options->scalar_expansion || */
6780+ /* options->scalar_renaming) */
6781+ /* candl_dependence_prune_scalar_waw(scop, options, &dependence); */
6782
6783 /* Final treatment for scalar analysis. */
6784 int check = 0;
6785 if (options->scalar_renaming)
6786- check = candl_dependence_scalar_renaming (program, options, &dependence);
6787+ check = candl_dependence_scalar_renaming(scop, options, &dependence);
6788+
6789 if (! check && options->scalar_privatization)
6790- candl_dependence_prune_with_privatization (program, options, &dependence);
6791+ candl_dependence_prune_with_privatization(scop, options, &dependence);
6792
6793 /* Compute the last writer */
6794- if (options->lastwriter) {
6795- candl_compute_last_writer(dependence, program);
6796- }
6797+ if (options->lastwriter)
6798+ candl_compute_last_writer(dependence, scop);
6799
6800+ #if defined(CANDL_COMPILE_PRUNNING_C)
6801 /* Remove some transitively covered dependences (experimental). */
6802 if (options->prune_dups)
6803- dependence = candl_dependence_prune_transitively_covered (dependence);
6804+ dependence = candl_dependence_prune_transitively_covered(dependence);
6805+ #endif
6806
6807 return dependence;
6808 }
6809
6810
6811+
6812+/**
6813+ * candl_dependence_add_extension function:
6814+ * this function builds the dependence graph for a scop list
6815+ * according to some user options (options).
6816+ * For each scop the dependence graph is added in the extension of the scop.
6817+ * Any old dependence graph in the extension is deleted.
6818+ *
6819+ * @param[in,out] scop A osl scop
6820+ * @param[in] options Candl options
6821+ */
6822+void candl_dependence_add_extension(osl_scop_p scop, candl_options_p options) {
6823+
6824+ while (scop) {
6825+ /* Calculating dependences. */
6826+ osl_dependence_p dep = osl_generic_lookup(scop->extension,
6827+ OSL_URI_DEPENDENCE);
6828+ if (dep != NULL) {
6829+ osl_generic_remove(&scop->extension, OSL_URI_DEPENDENCE);
6830+ CANDL_info("Deleting old dependences found in the options tag.");
6831+ }
6832+
6833+ dep = candl_dependence(scop, options);
6834+
6835+ osl_generic_p data = osl_generic_shell(dep, osl_dependence_interface());
6836+ data->next = scop->extension;
6837+ scop->extension = data;
6838+
6839+ scop = scop->next;
6840+ }
6841+}
6842+
6843 /******************************************************************************
6844 * Scalar analysis functions *
6845 ******************************************************************************/
6846@@ -1393,29 +1019,39 @@ candl_dependence_p candl_dependence(candl_program_p program,
6847 /**
6848 * candl_dependence_var_is_scalar function:
6849 * This function returns true if the variable indexed by 'var_index'
6850- * is a scalar in the whole program.
6851+ * is a scalar in the whole scop.
6852 */
6853-int
6854-candl_dependence_var_is_scalar (candl_program_p program, int var_index)
6855-{
6856- CandlMatrix* m;
6857- int i, j, k, cpt;
6858-
6859- for (i = 0; i < program->nb_statements; ++i)
6860- for (m = program->statement[i]->read, cpt = 0; cpt < 2; ++cpt,
6861- m = program->statement[i]->written)
6862- for (j = 0; j < m->NbRows; ++j)
6863- if (CANDL_get_si(m->p[j][0]) == var_index)
6864- {
6865- /* Ensure it is not an array. */
6866- if (j < m->NbRows - 1 && CANDL_get_si(m->p[j + 1][0]) == 0)
6867- return 0;
6868- /* Ensure the access function is '0'. */
6869- for (k = 1; k < m->NbColumns; ++k)
6870- if (CANDL_get_si(m->p[j][k]) != 0)
6871- return 0;
6872- }
6873-
6874+int candl_dependence_var_is_scalar(osl_scop_p scop, int var_index) {
6875+ osl_statement_p statement;
6876+ osl_relation_list_p access;
6877+ osl_relation_p elt;
6878+ int precision = scop->context->precision;
6879+ int i;
6880+ int id, row;
6881+
6882+ statement = scop->statement;
6883+ while (statement != NULL) {
6884+ access = statement->access;
6885+ while (access != NULL) {
6886+ elt = access->elt;
6887+ id = osl_relation_get_array_id(elt);
6888+ row = candl_util_relation_get_line(elt, 0);
6889+ if (id == var_index) {
6890+ /* Ensure it is not an array. */
6891+ if (elt->nb_output_dims > 1)
6892+ return 0;
6893+ /* Ensure the access function is '0'. */
6894+ if (!osl_int_zero(precision, elt->m[row][0]))
6895+ return 0;
6896+ for (i = 2; i < elt->nb_columns-2; ++i) /* jmp the 'Arr' */
6897+ if (!osl_int_zero(precision, elt->m[row][i]))
6898+ return 0;
6899+ }
6900+ access = access->next;
6901+ }
6902+ statement = statement->next;
6903+ }
6904+
6905 return 1;
6906 }
6907
6908@@ -1427,61 +1063,33 @@ candl_dependence_var_is_scalar (candl_program_p program, int var_index)
6909 * variable in the statement list.
6910 *
6911 */
6912-static
6913-void
6914-candl_dependence_expand_scalar(CandlStatement** sl,
6915- int scalar_idx)
6916-{
6917- CandlMatrix* m;
6918- int i, l, n, j;
6919+static void candl_dependence_expand_scalar(osl_statement_p* sl,
6920+ int scalar_idx) {
6921+ osl_relation_list_p access;
6922+ osl_relation_p elt;
6923+ int id, row;
6924+ int precision = sl[0]->scattering->precision;
6925+ int i;
6926
6927 /* Iterate on all statements of the list. */
6928- for (i = 0; sl[i] != NULL; ++i)
6929- {
6930- /* Check if the scalar is referenced in the 'read' access
6931- function. */
6932- for (j = 0; j < sl[i]->read->NbRows &&
6933- CANDL_get_si(sl[i]->read->p[j][0]) != scalar_idx; ++j)
6934- ;
6935- /* It is. */
6936- if (j < sl[i]->read->NbRows)
6937- {
6938- /* Add a row to the 'read' matrix, just after the reference
6939- to 'scalar_idx'. */
6940- m = candl_matrix_malloc (sl[i]->read->NbRows +1,
6941- sl[i]->read->NbColumns);
6942- for (l = 0; l <= j; ++l)
6943- for (n = 0; n < m->NbColumns; ++n)
6944- CANDL_assign(m->p[l][n], sl[i]->read->p[l][n]);
6945- for (++l; l < m->NbRows; ++l)
6946- for (n = 0; n < m->NbColumns; ++n)
6947- CANDL_assign(m->p[l][n], sl[i]->read->p[l - 1][n]);
6948- for (n = 0; n < m->NbColumns; ++n)
6949- CANDL_set_si(m->p[j + 1][n], 0);
6950- candl_matrix_free (sl[i]->read);
6951- sl[i]->read = m;
6952- }
6953-
6954- /* Same for 'written' access function. */
6955- for (j = 0; j < sl[i]->written->NbRows &&
6956- CANDL_get_si(sl[i]->written->p[j][0]) != scalar_idx;++j)
6957- ;
6958- if (j < sl[i]->written->NbRows)
6959- {
6960- m = candl_matrix_malloc (sl[i]->written->NbRows +1,
6961- sl[i]->written->NbColumns);
6962- for (l = 0; l <= j; ++l)
6963- for (n = 0; n < m->NbColumns; ++n)
6964- CANDL_assign(m->p[l][n], sl[i]->written->p[l][n]);
6965- for (++l; l < m->NbRows; ++l)
6966- for (n = 0; n < m->NbColumns; ++n)
6967- CANDL_assign(m->p[l][n], sl[i]->written->p[l - 1][n]);
6968- for (n = 0; n < m->NbColumns; ++n)
6969- CANDL_set_si(m->p[j + 1][n], 0);
6970- candl_matrix_free (sl[i]->written);
6971- sl[i]->written = m;
6972- }
6973+ for (i = 0; sl[i] != NULL; ++i) {
6974+
6975+ /* Check if the scalar is referenced in the 'read' access
6976+ function. */
6977+ access = sl[i]->access;
6978+ for (; access != NULL ; access = access->next) {
6979+ elt = access->elt;
6980+ id = osl_relation_get_array_id(elt);
6981+ row = candl_util_relation_get_line(elt, 0);
6982+ if (id == scalar_idx) {
6983+ row = elt->nb_rows;
6984+ osl_relation_insert_blank_row(elt, row);
6985+ osl_relation_insert_blank_column(elt, 1 + elt->nb_output_dims);
6986+ osl_int_set_si(precision, &elt->m[row][1 + elt->nb_output_dims], -1);
6987+ elt->nb_output_dims++;
6988+ }
6989 }
6990+ }
6991 }
6992
6993
6994@@ -1490,51 +1098,70 @@ candl_dependence_expand_scalar(CandlStatement** sl,
6995 * This function returns a chain of statements as a feshly allocated
6996 * array of pointer on statements, of all statements reading or
6997 * writing the variable 'var_index', surrounded by the 'level' common
6998- * loops of 'dom'. Output is a NULL-terminated array.
6999+ * loops of 'dom'.
7000+ * Output is a NULL-terminated array. We don't create a chained list,
7001+ * because it demands to clone every statements each time, and we need
7002+ * to clone the field usr too.
7003 */
7004-CandlStatement**
7005-candl_dependence_refvar_chain(candl_program_p program, CandlStatement* dom,
7006- int var_index, int level)
7007-{
7008- /* No or empty program -> no chain! */
7009- if (program == NULL || program->nb_statements == 0)
7010+osl_statement_p* candl_dependence_refvar_chain(osl_scop_p scop,
7011+ osl_statement_p dom, int var_index, int level) {
7012+ /* No or empty scop -> no chain! */
7013+ if (scop == NULL || scop->statement == NULL)
7014 return NULL;
7015
7016+ osl_statement_p* res; /* not a chained list, but an array of statement */
7017+ osl_statement_p statement;
7018+ candl_statement_usr_p dom_usr;
7019+ candl_statement_usr_p stmt_usr;
7020+ int i;
7021 int buffer_size = 64;
7022- CandlStatement** res =
7023- (CandlStatement**) malloc(buffer_size * sizeof(CandlStatement*));
7024- int i, j, count = 0;
7025- CandlStatement* s;
7026+ int count = 0;
7027
7028 /* If no dominator is provided, assume we start with the first statement. */
7029 if (dom == NULL)
7030- dom = program->statement[0];
7031- for (i = 0; i < program->nb_statements && program->statement[i] != dom; ++i)
7032- ;
7033+ dom = scop->statement;
7034+
7035+ dom_usr = dom->usr;
7036+
7037+ statement = scop->statement;
7038+ while (statement != NULL && statement != dom)
7039+ statement = statement->next;
7040+
7041 /* The dominator is not in the list of statements. */
7042- if (i == program->nb_statements)
7043+ if (statement == NULL)
7044 return NULL;
7045- for (; i < program->nb_statements; ++i)
7046- {
7047- s = program->statement[i];
7048- /* We look for exactly 'level' common loops. */
7049- if (s->depth < level)
7050- continue;
7051- /* Ensure it has 'level' common loop(s) with the dominator. */
7052- for (j = 0; j < level&& s->index[j] == dom->index[j]; ++j)
7053- ;
7054- if (j < level)
7055- continue;
7056- /* Ensure the variable is referenced. */
7057- if (candl_dependence_var_is_ref (s, var_index) != CANDL_VAR_UNDEF)
7058- {
7059- res[count++] = s;
7060- if (count == buffer_size)
7061- res = realloc(res, (buffer_size*=2) * sizeof(CandlStatement*));
7062- }
7063+
7064+ CANDL_malloc(res, osl_statement_p*, sizeof(osl_statement_p) * buffer_size);
7065+
7066+ for (; statement != NULL; statement = statement->next) {
7067+ stmt_usr = statement->usr;
7068+
7069+ /* We look for exactly 'level' common loops. */
7070+ if (stmt_usr->depth < level)
7071+ continue;
7072+
7073+ /* Ensure it has 'level' common loop(s) with the dominator. */
7074+ for (i = 0; i < level &&
7075+ stmt_usr->index[i] == dom_usr->index[i];
7076+ ++i)
7077+ ;
7078+
7079+ if (i < level)
7080+ continue;
7081+
7082+ /* Ensure the variable is referenced. */
7083+ if (candl_dependence_var_is_ref(statement, var_index) != CANDL_VAR_UNDEF) {
7084+ if (count == buffer_size) {
7085+ buffer_size *= 2;
7086+ CANDL_realloc(res, osl_statement_p*,
7087+ sizeof(osl_statement_p) * buffer_size);
7088+ }
7089+ res[count++] = statement;
7090 }
7091+ }
7092
7093- res = realloc(res, (count + 1) * sizeof(CandlStatement*));
7094+ CANDL_realloc(res, osl_statement_p*,
7095+ sizeof(osl_statement_p) * (count+1));
7096 res[count] = NULL;
7097
7098 return res;
7099@@ -1546,30 +1173,44 @@ candl_dependence_refvar_chain(candl_program_p program, CandlStatement* dom,
7100 * This function checks if a var 'var_index' is referenced (DEF or
7101 * USE) by the statement.
7102 */
7103-int
7104-candl_dependence_var_is_ref(CandlStatement* s, int var_index)
7105-{
7106- int j;
7107+int candl_dependence_var_is_ref(osl_statement_p s, int var_index) {
7108+ osl_relation_list_p access;
7109+ osl_relation_p elt;
7110+ int id;
7111 int ret = CANDL_VAR_UNDEF;
7112-
7113- if (s)
7114- {
7115- for (j = 0; s->read && j < s->read->NbRows; ++j)
7116- if (CANDL_get_si(s->read->p[j][0]) == var_index)
7117- {
7118- ret = CANDL_VAR_IS_USED;
7119- break;
7120- }
7121- for (j = 0; s->written && j < s->written->NbRows; ++j)
7122- if (CANDL_get_si(s->written->p[j][0]) == var_index)
7123- {
7124- if (ret == CANDL_VAR_IS_USED)
7125- ret = CANDL_VAR_IS_DEF_USED;
7126- else
7127- ret = CANDL_VAR_IS_DEF;
7128- break;
7129- }
7130+
7131+ if (s) {
7132+ /* read access */
7133+ access = s->access;
7134+ while (access != NULL) {
7135+ elt = access->elt;
7136+ if (elt->type == OSL_TYPE_READ) {
7137+ id = osl_relation_get_array_id(elt);
7138+ if (id == var_index) {
7139+ ret = CANDL_VAR_IS_USED;
7140+ break;
7141+ }
7142+ }
7143+ access = access->next;
7144+ }
7145+
7146+ /* right access */
7147+ access = s->access;
7148+ while (access != NULL) {
7149+ elt = access->elt;
7150+ if (elt->type != OSL_TYPE_READ) {
7151+ id = osl_relation_get_array_id(elt);
7152+ if (id == var_index) {
7153+ if (ret == CANDL_VAR_IS_USED)
7154+ ret = CANDL_VAR_IS_DEF_USED;
7155+ else
7156+ ret = CANDL_VAR_IS_DEF;
7157+ break;
7158+ }
7159+ }
7160+ access = access->next;
7161 }
7162+ }
7163
7164 return ret;
7165 }
7166@@ -1580,29 +1221,26 @@ candl_dependence_var_is_ref(CandlStatement* s, int var_index)
7167 * This function assigns to the Entier 'lb' the lexmin of variable
7168 * 'col'-1 in the polyhedron 'm'.
7169 */
7170-static
7171-void
7172-candl_dependence_compute_lb (CandlMatrix* m, Entier* lb, int col)
7173-{
7174+static void candl_dependence_compute_lb(osl_relation_p m, Entier* lb, int col) {
7175 PipOptions* options;
7176 PipQuast* solution;
7177 PipList* l;
7178- options = pip_options_init ();
7179+ options = pip_options_init();
7180 options->Simplify = 1;
7181 options->Urs_parms = -1;
7182 options->Urs_unknowns = -1;
7183 /* Compute lexmin. */
7184- solution = pip_solve (m, NULL, -1, options);
7185+ solution = pip_solve_osl(m, NULL, -1, options);
7186+
7187 if ((solution != NULL) &&
7188- ((solution->list != NULL) || (solution->condition != NULL)))
7189- {
7190- l = solution->list;
7191- while (col-- > 1)
7192- l = l->next;
7193- CANDL_assign(*lb, l->vector->the_vector[0]);
7194- }
7195- pip_options_free (options);
7196- pip_quast_free (solution);
7197+ ((solution->list != NULL) || (solution->condition != NULL))) {
7198+ l = solution->list;
7199+ while (col-- > 1)
7200+ l = l->next;
7201+ CANDL_assign(*lb, l->vector->the_vector[0]);
7202+ }
7203+ pip_options_free(options);
7204+ pip_quast_free(solution);
7205 }
7206
7207
7208@@ -1613,66 +1251,95 @@ candl_dependence_compute_lb (CandlMatrix* m, Entier* lb, int col)
7209 * considered iterator dimensions.
7210 *
7211 */
7212-int
7213-candl_dependence_check_domain_is_included(CandlStatement* s1,
7214- CandlStatement* s2,
7215- CandlMatrix* context,
7216- int level)
7217-{
7218+int candl_dependence_check_domain_is_included(osl_statement_p s1,
7219+ osl_statement_p s2,
7220+ osl_relation_p context,
7221+ int level) {
7222+ candl_statement_usr_p s1_usr = s1->usr;
7223+ candl_statement_usr_p s2_usr = s2->usr;
7224+ osl_relation_p matrix;
7225 int max = level;
7226- Entier lb; CANDL_init(lb);
7227- max = s1->depth < max ? s1->depth : max;
7228- max = s2->depth < max ? s2->depth : max;
7229- CandlMatrix* m = candl_matrix_malloc(s2->domain->NbRows + s2->depth - max +1,
7230- s2->domain->NbColumns);
7231 int i, j;
7232+ int precision = s2->domain->precision;
7233+ Entier lb;
7234+ osl_int_t osl_lb;
7235+
7236+ CANDL_init(lb);
7237+ osl_int_init(precision, &osl_lb);
7238+
7239+ if (s1_usr->depth < max) max = s1_usr->depth;
7240+ if (s2_usr->depth < max) max = s2_usr->depth;
7241+
7242+ matrix = osl_relation_pmalloc(precision,
7243+ s2->domain->nb_rows + s2_usr->depth - max + 1,
7244+ s2->domain->nb_columns);
7245+
7246 /* Duplicate s2 to the dest matrix. */
7247- for (i = 0; i < s2->domain->NbRows; ++i)
7248- for (j = 0; j < s2->domain->NbColumns; ++j)
7249- CANDL_assign(m->p[i][j], s2->domain->p[i][j]);
7250+ for (i = 0; i < s2->domain->nb_rows; ++i) {
7251+ for (j = 0; j < s2->domain->nb_columns; ++j)
7252+ osl_int_assign(precision,
7253+ &matrix->m[i][j], s2->domain->m[i][j]);
7254+ }
7255+
7256 /* Make useless dimensions equal to 1. */
7257- for (j = 0; j < s2->depth - max; ++j)
7258- {
7259- candl_dependence_compute_lb (s2->domain, &lb, j + 1 + max);
7260- CANDL_assign(m->p[i][m->NbColumns - 1], lb);
7261- CANDL_set_si(m->p[i++][j + 1 + max], -1);
7262- }
7263+ for (j = 0; j < s2_usr->depth - max; ++j) {
7264+ candl_dependence_compute_lb(s2->domain, &lb, j + 1 + max);
7265+ #ifdef CANDL_LINEAR_VALUE_IS_INT
7266+ osl_lb.sp = lb;
7267+ #elif defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
7268+ osl_lb.dp = lb;
7269+ #elif defined(CANDL_LINEAR_VALUE_IS_MP)
7270+ mpz_set(*((mpz_t*)osl_lb.mp), lb);
7271+ #endif
7272+ osl_int_assign(precision,
7273+ &matrix->m[i][matrix->nb_columns - 1], osl_lb);
7274+ osl_int_set_si(precision,
7275+ &matrix->m[i++][j+1+max], -1);
7276+ }
7277+
7278 /* Iterate on all constraints of s1, and check them. */
7279- for (i = 0; i < s1->domain->NbRows; ++i)
7280- {
7281- /* Skip constraints defining other iterators. */
7282- for (j = max + 1; j <= s1->depth; ++j)
7283- if (CANDL_get_si(s1->domain->p[i][j]) != 0)
7284- break;
7285- if (j <= s1->depth)
7286- continue;
7287- /* Invert the constraint, and add it to m. */
7288- for (j = 0; j <= max; ++j)
7289- {
7290- CANDL_assign(m->p[m->NbRows - 1][j], s1->domain->p[i][j]);
7291- CANDL_oppose(m->p[m->NbRows - 1][j], m->p[m->NbRows - 1][j]);
7292- }
7293- for (j = s1->depth + 1; j < s1->domain->NbColumns; ++j)
7294- {
7295- CANDL_assign(m->p[m->NbRows - 1][j - s1->depth + s2->depth],
7296- s1->domain->p[i][j]);
7297- CANDL_oppose(m->p[m->NbRows - 1][j - s1->depth + s2->depth],
7298- m->p[m->NbRows - 1][j - s1->depth + s2->depth]);
7299- }
7300- /* Make the inequality strict. */
7301- CANDL_decrement(m->p[m->NbRows - 1][m->NbColumns - 1],
7302- m->p[m->NbRows - 1][m->NbColumns - 1]);
7303- if (candl_matrix_check_point (m, context))
7304- {
7305- /* There is a point. dom(s1) - dom(s2) > 0. */
7306- CANDL_clear(lb);
7307- candl_matrix_free(m);
7308- return 0;
7309- }
7310+ for (i = 0; i < s1->domain->nb_rows; ++i) {
7311+ /* Skip constraints defining other iterators. */
7312+ for (j = max + 1; j <= s1_usr->depth; ++j) {
7313+ if (!osl_int_zero(precision, s1->domain->m[i][j]))
7314+ break;
7315+ }
7316+ if (j <= s1_usr->depth)
7317+ continue;
7318+ /* Invert the constraint, and add it to matrix. */
7319+ for (j = 0; j <= max; ++j) {
7320+ osl_int_assign(precision,
7321+ &matrix->m[matrix->nb_rows - 1][j],
7322+ s1->domain->m[i][j]);
7323+ osl_int_oppose(precision,
7324+ &matrix->m[matrix->nb_rows - 1][j],
7325+ matrix->m[matrix->nb_rows - 1][j]);
7326+ }
7327+ for (j = s1_usr->depth + 1; j < s1->domain->nb_columns; ++j) {
7328+ osl_int_assign(precision,
7329+ &matrix->m[matrix->nb_rows - 1][j - s1_usr->depth + s2_usr->depth],
7330+ s1->domain->m[i][j]);
7331+ osl_int_oppose(precision,
7332+ &matrix->m[matrix->nb_rows - 1][j - s1_usr->depth + s2_usr->depth],
7333+ matrix->m[matrix->nb_rows - 1][j - s1_usr->depth + s2_usr->depth]);
7334+ }
7335+ /* Make the inequality strict. */
7336+ osl_int_decrement(precision,
7337+ &matrix->m[matrix->nb_rows - 1][matrix->nb_columns - 1],
7338+ matrix->m[matrix->nb_rows - 1][matrix->nb_columns - 1]);
7339+
7340+ if (candl_matrix_check_point(matrix, context)) {
7341+ /* There is a point. dom(s1) - dom(s2) > 0. */
7342+ CANDL_clear(lb);
7343+ osl_int_clear(precision, &osl_lb);
7344+ osl_relation_free(matrix);
7345+ return 0;
7346 }
7347+ }
7348
7349 CANDL_clear(lb);
7350- candl_matrix_free(m);
7351+ osl_int_clear(precision, &osl_lb);
7352+ osl_relation_free(matrix);
7353
7354 return 1;
7355 }
7356@@ -1680,49 +1347,48 @@ candl_dependence_check_domain_is_included(CandlStatement* s1,
7357
7358 /**
7359 * candl_dependence_extract_scalar_variables function:
7360- * This functions returns a -1-terminated array of the program scalar
7361+ * This functions returns a -1-terminated array of the scop scalar
7362 * variables.
7363 */
7364-int*
7365-candl_dependence_extract_scalar_variables (candl_program_p program)
7366-{
7367- /* FIXME: implement a real buffer. */
7368- int scalars[1024];
7369+int* candl_dependence_extract_scalar_variables(osl_scop_p scop) {
7370+ osl_statement_p statement;
7371+ osl_relation_p elt;
7372+ osl_relation_list_p access;
7373+ int scalars[1024]; /* FIXME: implement a real buffer. */
7374 int checked[1024];
7375- int i, j, k, idx, cpt;
7376+ int i, idx;
7377 int count_s = 0, count_c = 0;
7378- CandlMatrix* m;
7379-
7380+
7381 /* Detect all scalar variables. */
7382- for (i = 0; i < program->nb_statements; ++i)
7383- for (m = program->statement[i]->read, cpt = 0; cpt < 2; ++cpt,
7384- m = program->statement[i]->written)
7385- for (j = 0; j < m->NbRows; ++j)
7386- {
7387- idx = CANDL_get_si(m->p[j][0]);
7388- if (idx != 0)
7389- {
7390- for (k = 0; k < count_s && scalars[k] != idx; ++k)
7391- ;
7392- if (k == count_s)
7393- {
7394- for (k = 0; k < count_c && checked[k] != idx; ++k)
7395- ;
7396- if (k == count_c)
7397- {
7398- if (candl_dependence_var_is_scalar(program, idx))
7399- scalars[count_s++] = idx;
7400- else
7401- checked[count_c++] = idx;
7402- }
7403- if (count_s == 1024 || count_c == 1024)
7404- CANDL_FAIL("Error: Buffer size too small");
7405- }
7406- }
7407- }
7408-
7409+ statement = scop->statement;
7410+ while (statement != NULL) {
7411+ access = statement->access;
7412+ while (access != NULL) {
7413+ elt = access->elt;
7414+ idx = osl_relation_get_array_id(elt);
7415+
7416+ for (i = 0; i < count_s && scalars[i] != idx; ++i)
7417+ ;
7418+ if (i == count_s) {
7419+ for (i = 0; i < count_c && checked[i] != idx; ++i)
7420+ ;
7421+ if (i == count_c) {
7422+ if (candl_dependence_var_is_scalar(scop, idx))
7423+ scalars[count_s++] = idx;
7424+ else
7425+ checked[count_c++] = idx;
7426+ }
7427+ if (count_s == 1024 || count_c == 1024)
7428+ CANDL_error("Error: Buffer size too small");
7429+ }
7430+ access = access->next;
7431+ }
7432+ statement = statement->next;
7433+ }
7434+
7435 /* Rearrange the array to the exact size. */
7436- int* res = (int*) malloc((count_s + 1) * sizeof(int));
7437+ int *res;
7438+ CANDL_malloc(res, int*, (count_s + 1) * sizeof(int));
7439 for (i = 0; i < count_s; ++i)
7440 res[i] = scalars[i];
7441 res[i] = -1;
7442@@ -1732,88 +1398,46 @@ candl_dependence_extract_scalar_variables (candl_program_p program)
7443
7444
7445 /**
7446- * candl_dependence_get_array_refs_in_dep function:
7447- * This function return the array indices referenced in the
7448- * dependence.
7449- */
7450-static
7451-void
7452-candl_dependence_get_array_refs_in_dep (CandlDependence* tmp, int* refs,
7453- int* reft)
7454-{
7455- if (! tmp)
7456- return;
7457- switch (tmp->type)
7458- {
7459- case CANDL_RAR:
7460- *refs = CANDL_get_si(tmp->source->read->p[tmp->ref_source][0]);
7461- *reft = CANDL_get_si(tmp->target->read->p[tmp->ref_target][0]);
7462- break;
7463- case CANDL_RAW:
7464- case CANDL_RAW_SCALPRIV:
7465- *refs = CANDL_get_si(tmp->source->written->p[tmp->ref_source][0]);
7466- *reft = CANDL_get_si(tmp->target->read->p[tmp->ref_target][0]);
7467- break;
7468- case CANDL_WAR:
7469- *refs = CANDL_get_si(tmp->source->read->p[tmp->ref_source][0]);
7470- *reft = CANDL_get_si(tmp->target->written->p[tmp->ref_target][0]);
7471- break;
7472- case CANDL_WAW:
7473- *refs = CANDL_get_si(tmp->source->written->p[tmp->ref_source][0]);
7474- *reft = CANDL_get_si(tmp->target->written->p[tmp->ref_target][0]);
7475- break;
7476- default:
7477- exit(1);
7478- }
7479-}
7480-
7481-
7482-/**
7483- * candl_dependence_prune_scalar_waw function:
7484+ * osl_dependence_prune_scalar_waw function:
7485 * This function removes all WAW dependences between the same scalar
7486 * (they are useless dependences).
7487 */
7488-void
7489-candl_dependence_prune_scalar_waw (candl_program_p program,
7490- CandlOptions* options,
7491- CandlDependence** deps)
7492-{
7493+void osl_dependence_prune_scalar_waw(osl_scop_p scop,
7494+ candl_options_p options,
7495+ osl_dependence_p* deps) {
7496 int* scalars;
7497 int i;
7498 int refs, reft;
7499- CandlDependence* tmp;
7500- CandlDependence* next;
7501- CandlDependence* pred = NULL;
7502+ osl_dependence_p tmp;
7503+ osl_dependence_p next;
7504+ osl_dependence_p pred = NULL;
7505
7506 if (options->verbose)
7507 fprintf (stderr, "[Candl] Scalar Analysis: Remove all WAW between the same"
7508- " scalar\n");
7509-
7510- scalars = candl_dependence_extract_scalar_variables (program);
7511-
7512- for (tmp = *deps; tmp; )
7513- {
7514- candl_dependence_get_array_refs_in_dep (tmp, &refs, &reft);
7515- if (refs == reft && tmp->type == CANDL_WAW)
7516- {
7517- for (i = 0; scalars[i] != -1 && scalars[i] != refs; ++i)
7518- ;
7519- if (scalars[i] != -1)
7520- {
7521- candl_matrix_free (tmp->domain);
7522- next = tmp->next;
7523- if (pred == NULL)
7524- *deps = next;
7525- else
7526- pred->next = next;
7527- free (tmp);
7528- tmp = next;
7529- continue;
7530- }
7531- }
7532- pred = tmp;
7533- tmp = tmp->next;
7534+ " scalar\n");
7535+
7536+ scalars = candl_dependence_extract_scalar_variables(scop);
7537+
7538+ for (tmp = *deps; tmp; ) {
7539+ candl_dependence_get_array_refs_in_dep(tmp, &refs, &reft);
7540+ if (refs == reft && tmp->type == OSL_DEPENDENCE_WAW) {
7541+ for (i = 0; scalars[i] != -1 && scalars[i] != refs; ++i)
7542+ ;
7543+ if (scalars[i] != -1) {
7544+ osl_relation_free(tmp->domain);
7545+ next = tmp->next;
7546+ if (pred == NULL)
7547+ *deps = next;
7548+ else
7549+ pred->next = next;
7550+ free(tmp);
7551+ tmp = next;
7552+ continue;
7553+ }
7554 }
7555+ pred = tmp;
7556+ tmp = tmp->next;
7557+ }
7558
7559 free(scalars);
7560 }
7561@@ -1824,160 +1448,189 @@ candl_dependence_prune_scalar_waw (candl_program_p program,
7562 * This function renames scalars in the program. In case scalars have
7563 * been renamed, the dependence analysis is re-run.
7564 */
7565-int
7566-candl_dependence_scalar_renaming (candl_program_p program,
7567- CandlOptions* options,
7568- CandlDependence** deps)
7569-{
7570+int candl_dependence_scalar_renaming(osl_scop_p scop,
7571+ candl_options_p options,
7572+ osl_dependence_p* deps) {
7573+ osl_statement_p *statement; /* not a chained list */
7574+ osl_statement_p iter;
7575+ osl_statement_p defs[1024];
7576+ osl_statement_p uses[1024];
7577+ osl_statement_p last_def;
7578+ osl_statement_p *current; /* not a chained list */
7579+ osl_relation_p elt;
7580+ osl_relation_list_p access;
7581+ candl_statement_usr_p usr;
7582+ candl_statement_usr_p last_usr;
7583 int i, j, k;
7584- CandlStatement** stmts;
7585- CandlStatement* defs[1024];
7586- CandlStatement* uses[1024];
7587- CandlStatement* current[program->nb_statements];
7588- int parts[program->nb_statements];
7589- CandlStatement* s;
7590- CandlStatement* last_def;
7591- CandlMatrix* m;
7592+ int nb_statements = 0;
7593+ int *parts;
7594 int defs_c, uses_c;
7595- int val, cpt, tmp, has_changed = 0;
7596+ int *scalars;
7597+ int precision = scop->context->precision;
7598+ int row;
7599+ int tmp, has_changed = 0;
7600 int newvar = 0;
7601
7602- for (i = 0; i < program->nb_statements; ++i)
7603- current[i] = NULL;
7604-
7605 if (options->verbose)
7606 fprintf (stderr, "[Candl] Scalar Analysis: Perform scalar renaming\n");
7607-
7608+
7609 /* Compute the first free variable index seed. */
7610- for (i = 0; i < program->nb_statements; ++i)
7611- for (m = program->statement[i]->read, cpt = 0; cpt < 2;
7612- ++cpt, m = program->statement[i]->written)
7613- for (j = 0; j < m->NbRows; ++j)
7614- if (CANDL_get_si(m->p[j][0]) >= newvar)
7615- newvar = CANDL_get_si(m->p[j][0]) + 1;
7616+ for (iter = scop->statement; iter != NULL; iter = iter->next) {
7617+ access = iter->access;
7618+ for (; access != NULL; access = access->next) {
7619+ elt = access->elt;
7620+ tmp = osl_relation_get_array_id(elt);
7621+ if (tmp >= newvar)
7622+ newvar = tmp + 1;
7623+ }
7624+ nb_statements++;
7625+ }
7626
7627+ /* Init */
7628+ CANDL_malloc(current, osl_statement_p*, sizeof(osl_statement_p) * nb_statements);
7629+ CANDL_malloc(parts, int*, sizeof(int) * nb_statements);
7630+
7631 /* Get the list of scalars. */
7632- int* scalars = candl_dependence_extract_scalar_variables (program);
7633+ scalars = candl_dependence_extract_scalar_variables(scop);
7634
7635 /* Iterate on all scalars. */
7636- for (i = 0; scalars[i] != -1; ++i)
7637- {
7638- /* Get all statements referencing the scalar. */
7639- stmts = candl_dependence_refvar_chain (program, NULL, scalars[i], 0);
7640-
7641- /* If the chain starts by a USE, we can't do anything. */
7642- if (stmts[0] == NULL || candl_dependence_var_is_ref (stmts[0], scalars[i])
7643- != CANDL_VAR_IS_DEF)
7644- {
7645- free (stmts);
7646- continue;
7647- }
7648-
7649- /* Get all defs. */
7650- for (j = 0, defs_c = 0; stmts[j]; ++j)
7651- if (candl_dependence_var_is_ref (stmts[j], scalars[i])
7652- == CANDL_VAR_IS_DEF)
7653- defs[defs_c++] = stmts[j];
7654- /* Get all uses. */
7655- for (j = 0, uses_c = 0; stmts[j]; ++j)
7656- {
7657- val = candl_dependence_var_is_ref (stmts[j], scalars[i]);
7658- if (val == CANDL_VAR_IS_USED || val == CANDL_VAR_IS_DEF_USED)
7659- uses[uses_c++] = stmts[j];
7660- }
7661-
7662- /* Clean buffer. */
7663- for (j = 0; j < program->nb_statements; ++j)
7664- current[j] = NULL;
7665-
7666- free (stmts);
7667-
7668- /* Iterate on all DEFs. */
7669- for (j = 0, last_def = NULL; j < defs_c; ++j)
7670- {
7671- if (last_def == NULL)
7672- last_def = defs[j];
7673- else
7674- {
7675- /* Ensure the current DEF covers all iterations covered
7676- by the last checked one. */
7677- for (k = 0; k < last_def->depth && k < defs[j]->depth &&
7678- last_def->index[k] == defs[j]->index[k]; ++k)
7679- ;
7680- /* We only need to check when there are common loops. */
7681- if (k && ! candl_dependence_check_domain_is_included
7682- (last_def, defs[j], program->context, k + 1))
7683- {
7684- current[defs[j]->label] = last_def;
7685- continue;
7686- }
7687- else
7688- last_def = defs[j];
7689- }
7690- /* Create DEF-USE table. */
7691- for (k = 0; k < uses_c; ++k)
7692- if (uses[k]->label > defs[j]->label)
7693- current[uses[k]->label] = defs[j];
7694- }
7695-
7696- /* Initialize partition table. */
7697- for (j = 0; j < program->nb_statements; ++j)
7698- parts[j] = -1;
7699-
7700- /* Create partitions. */
7701- for (j = 0; j < defs_c; ++j)
7702- for (k = 0; k < program->nb_statements; ++k)
7703- if ((current[k] && current[k] == defs[j]) ||
7704- (k == defs[j]->label && current[defs[j]->label] == NULL))
7705- parts[k] = j;
7706-
7707- /* Check if it is needed to rename the scalar. */
7708- for (j = 0, tmp = -1; j < program->nb_statements; ++j)
7709- if (tmp == -1)
7710- {
7711- if (parts[j] != -1)
7712- tmp = parts[j];
7713- }
7714- else
7715- if (parts[j] != -1 && tmp != parts[j])
7716- break;
7717-
7718- /* Rename scalar variable. */
7719- if (j != program->nb_statements)
7720- for (j = 0, tmp = -1; j < program->nb_statements; ++j)
7721- if (parts[j] != -1)
7722- {
7723- if (tmp == -1)
7724- tmp = parts[j];
7725- else
7726- if (tmp != parts[j])
7727- has_changed = 1;
7728- s = program->statement[j];
7729- for (m = s->read, cpt = 0; cpt < 2; ++cpt, m = s->written)
7730- for (k = 0; k < m->NbRows; ++k)
7731- if (CANDL_get_si(m->p[k][0]) == scalars[i])
7732- {
7733- if (options->verbose)
7734- fprintf (stderr, "[Candl] Scalar analysis: Renamed "
7735- "variable %d to %d at statement S%d\n",
7736- scalars[i], newvar + parts[j], j);
7737- CANDL_set_si(m->p[k][0], newvar + parts[j]);
7738- }
7739- }
7740+ for (i = 0; scalars[i] != -1; ++i) {
7741+ /* Get all statements referencing the scalar. */
7742+ statement = candl_dependence_refvar_chain(scop, NULL, scalars[i], 0);
7743+
7744+ /* If the chain starts by a USE, we can't do anything. */
7745+ if (statement[0] == NULL ||
7746+ candl_dependence_var_is_ref(statement[0], scalars[i])
7747+ != CANDL_VAR_IS_DEF) {
7748+ free(statement);
7749+ continue;
7750 }
7751
7752- /* Redo the full dependence analysis, if needed. */
7753- if (has_changed)
7754- {
7755- int bopt = options->scalar_renaming;
7756- options->scalar_renaming = 0;
7757- if (options->scalar_privatization)
7758- free (program->scalars_privatizable);
7759- candl_dependence_free (*deps);
7760- *deps = candl_dependence (program, options);
7761- options->scalar_renaming = bopt;
7762+ /* Get all defs and all uses. */
7763+ defs_c = 0;
7764+ uses_c = 0;
7765+ for (j = 0; statement[j]; ++j) {
7766+ tmp = candl_dependence_var_is_ref(statement[j], scalars[i]);
7767+ switch (tmp) {
7768+ case CANDL_VAR_IS_USED:
7769+ case CANDL_VAR_IS_DEF_USED:
7770+ uses[uses_c++] = statement[j];
7771+ break;
7772+ case CANDL_VAR_IS_DEF:
7773+ defs[defs_c++] = statement[j];
7774+ break;
7775+ }
7776+ }
7777+
7778+ /* Clean buffer. */
7779+ j = 0;
7780+ for (iter = scop->statement; iter != NULL; iter = iter->next)
7781+ current[j++] = NULL;
7782+
7783+ free(statement);
7784+
7785+ /* Iterate on all DEFs. */
7786+ last_def = NULL;
7787+ for (j = 0; j < defs_c; ++j) {
7788+ if (last_def == NULL) {
7789+ last_def = defs[j];
7790+ } else {
7791+ /* Ensure the current DEF covers all iterations covered
7792+ by the last checked one. */
7793+ last_usr = last_def->usr;
7794+ usr = defs[j]->usr;
7795+ for (k = 0; k < last_usr->depth && k < usr->depth &&
7796+ last_usr->index[k] == usr->index[k];
7797+ ++k)
7798+ ;
7799+ /* We only need to check when there are common loops. */
7800+ if (k && ! candl_dependence_check_domain_is_included
7801+ (last_def, defs[j], scop->context, k + 1)) {
7802+ usr = defs[j]->usr;
7803+ current[usr->label] = last_def;
7804+ continue;
7805+ } else {
7806+ last_def = defs[j];
7807+ }
7808+ }
7809+ /* Create DEF-USE table. */
7810+ for (k = 0; k < uses_c; ++k) {
7811+ usr = uses[k]->usr;
7812+ if (usr->label > ((candl_statement_usr_p)defs[j]->usr)->label)
7813+ current[usr->label] = defs[j];
7814+ }
7815+ }
7816+
7817+ /* Initialize partition table. */
7818+ for (j = 0; j < nb_statements; ++j)
7819+ parts[j] = -1;
7820+
7821+ /* Create partitions. */
7822+ for (j = 0; j < defs_c; ++j) {
7823+ usr = defs[j]->usr;
7824+ for (k = 0; k < nb_statements; ++k)
7825+ if ((current[k] && current[k] == defs[j]) ||
7826+ (k == usr->label && current[usr->label] == NULL))
7827+ parts[k] = j;
7828+ }
7829+
7830+ /* Check if it is needed to rename the scalar. */
7831+ tmp = -1;
7832+ for (j = 0; j < nb_statements; ++j)
7833+ if (tmp == -1) {
7834+ if (parts[j] != -1)
7835+ tmp = parts[j];
7836+ } else {
7837+ if (parts[j] != -1 && tmp != parts[j])
7838+ break;
7839+ }
7840+
7841+ /* Rename scalar variable. */
7842+ if (j != nb_statements) {
7843+ tmp = -1;
7844+ j = 0;
7845+ for (iter = scop->statement ; iter != NULL ; iter = iter->next) {
7846+ if (parts[j] != -1) {
7847+ if (tmp == -1)
7848+ tmp = parts[j];
7849+ else if (tmp != parts[j])
7850+ has_changed = 1;
7851+
7852+ access = iter->access;
7853+ for (; access != NULL; access = access->next) {
7854+ elt = access->elt;
7855+ row = candl_util_relation_get_line(elt, 0);
7856+ tmp = osl_relation_get_array_id(elt);
7857+ if (tmp == scalars[i]) {
7858+ if (options->verbose)
7859+ fprintf (stderr, "[Candl] Scalar analysis: Renamed "
7860+ "variable %d to %d at statement S%d\n",
7861+ scalars[i], newvar + parts[j], j);
7862+ osl_int_set_si(precision,
7863+ &elt->m[row][elt->nb_columns - 1],
7864+ newvar + parts[j]);
7865+ }
7866+ }
7867+ }
7868+ j++;
7869+ }
7870 }
7871- free (scalars);
7872+ } /* end Iterate on all scalars */
7873+
7874+ /* Redo the full dependence analysis, if needed. */
7875+ if (has_changed) {
7876+ int bopt = options->scalar_renaming;
7877+ options->scalar_renaming = 0;
7878+ if (options->scalar_privatization)
7879+ free(((candl_scop_usr_p)scop->usr)->scalars_privatizable);
7880+ osl_dependence_free(*deps);
7881+ *deps = candl_dependence(scop, options);
7882+ options->scalar_renaming = bopt;
7883+ }
7884+
7885+ free(scalars);
7886+ free(current);
7887+ free(parts);
7888
7889 return has_changed;
7890 }
7891@@ -1988,188 +1641,171 @@ candl_dependence_scalar_renaming (candl_program_p program,
7892 * This function returns true if the dependence 'dep' is loop-carried
7893 * for loop 'loop_index', false otherwise.
7894 */
7895-int
7896-candl_dependence_is_loop_carried (candl_program_p program,
7897- CandlDependence* dep,
7898- int loop_index)
7899-{
7900+int candl_dependence_is_loop_carried(osl_scop_p scop,
7901+ osl_dependence_p dep,
7902+ int loop_index) {
7903+ osl_relation_p msrc = NULL, mtarg = NULL;
7904+ candl_statement_usr_p s_usr = dep->stmt_source_ptr->usr;
7905+ candl_statement_usr_p t_usr = dep->stmt_target_ptr->usr;
7906 int i, j;
7907+ int k, kp, l;
7908+ int row_k, row_kp;
7909+ int precision = scop->context->precision;
7910+
7911 /* Ensure source and sink share common loop 'loop_index', and that
7912 dependence depth is consistent with the considered loop. */
7913- for (i = 0; i < dep->source->depth; ++i)
7914- if (dep->source->index[i] == loop_index)
7915+ for (i = 0; i < s_usr->depth; ++i)
7916+ if (s_usr->index[i] == loop_index)
7917 break;
7918- if (i != dep->depth - 1 || i >= dep->target->depth)
7919+ if (i != dep->depth - 1 || i >= t_usr->depth)
7920 return 0;
7921- for (j = 0; j < dep->target->depth; ++j)
7922- if (dep->target->index[j] == loop_index)
7923+ for (j = 0; j < t_usr->depth; ++j)
7924+ if (t_usr->index[j] == loop_index)
7925 break;
7926 if (j != i)
7927 return 0;
7928-
7929- int k = 0;
7930- int l = 0;
7931- CandlMatrix* mats;
7932- if (dep->type == CANDL_WAR || dep->type == CANDL_RAR)
7933- mats = dep->source->read;
7934- else
7935- mats = dep->source->written;
7936- CandlMatrix* matt;
7937- if (dep->type == CANDL_RAW || dep->type == CANDL_RAW_SCALPRIV
7938- || dep->type == CANDL_RAR)
7939- matt = dep->target->read;
7940- else
7941- matt = dep->target->written;
7942-
7943- int src_ref_iter = 0;
7944- int dst_ref_iter = 0;
7945- for (k = 0; k == 0 ||
7946- (dep->ref_source + k < mats->NbRows &&
7947- CANDL_get_si(mats->p[dep->ref_source + k][0]) == 0); ++k)
7948- if (CANDL_get_si(mats->p[dep->ref_source + k][i + 1]) != 0)
7949- {
7950- src_ref_iter = 1;
7951- break;
7952- }
7953- for (k = 0; k == 0 ||
7954- (dep->ref_target + k < matt->NbRows &&
7955- CANDL_get_si(matt->p[dep->ref_target + k][0]) == 0); ++k)
7956- if (CANDL_get_si(matt->p[dep->ref_target + k][j + 1]) != 0)
7957- {
7958- dst_ref_iter = 1;
7959- break;
7960- }
7961+
7962+ msrc = candl_dependence_get_relation_ref_source_in_dep(dep);
7963+ mtarg = candl_dependence_get_relation_ref_target_in_dep(dep);
7964+
7965+ /* plus one for the Arr output dim */
7966+ int src_ref_iter = (candl_util_relation_get_line(msrc, i+1) != -1);
7967+ int dst_ref_iter = (candl_util_relation_get_line(mtarg,j+1) != -1);
7968
7969 /* Ensure it is not a basic loop-independent dependence (pure
7970 equality of the access functions for the surrounding iterators +
7971 parameters + constant, no occurence of the inner loop iterators,
7972 and contain the current loop iterator. */
7973 int must_test = 0;
7974- k = 0;
7975- do
7976- {
7977- // Ensure the reference do reference the current loop iterator
7978- // to be tested.
7979- if (CANDL_get_si(mats->p[dep->ref_source + k][i + 1]) != 0)
7980- {
7981- int kp = 0;
7982- do
7983- {
7984- if (CANDL_get_si(matt->p[dep->ref_target + kp][j + 1]) != 0)
7985- {
7986- // Ensure the access functions are equal for the
7987- // surrounding loop iterators, and no inner iterator
7988- // is referenced.
7989- for (l = 0; l <= i + 1; ++l)
7990- if (CANDL_get_si(mats->p[dep->ref_source + k][l]) !=
7991- CANDL_get_si(matt->p[dep->ref_target + kp][l]))
7992- {
7993- must_test = 1;
7994- break;
7995- }
7996- int m = l;
7997- if (!must_test)
7998- for (; l <= dep->source->depth; ++l)
7999- if (CANDL_get_si(mats->p[dep->ref_source + k][l]) != 0)
8000- {
8001- must_test = 1;
8002- break;
8003- }
8004- if (!must_test)
8005- for (; m <= dep->target->depth; ++m)
8006- if (CANDL_get_si(matt->p[dep->ref_target + kp][m]) != 0)
8007- {
8008- must_test = 1;
8009- break;
8010- }
8011- if (!must_test)
8012- for (; l < mats->NbColumns; ++l, ++m)
8013- if (CANDL_get_si(mats->p[dep->ref_source + k][l]) !=
8014- CANDL_get_si(matt->p[dep->ref_target + kp][m]))
8015- {
8016- must_test = 1;
8017- break;
8018- }
8019- }
8020- ++kp;
8021- }
8022- while (!must_test &&
8023- dep->ref_target + kp < matt->NbRows &&
8024- CANDL_get_si(matt->p[dep->ref_target + kp][0]) == 0);
8025- }
8026- ++k;
8027- }
8028+ k = 1; // start after the Arr column
8029+ row_k = candl_util_relation_get_line(msrc, k);
8030 while (!must_test &&
8031- dep->ref_source + k < mats->NbRows &&
8032- CANDL_get_si(mats->p[dep->ref_source + k][0]) == 0);
8033+ k < msrc->nb_output_dims &&
8034+ osl_int_zero(precision, msrc->m[row_k][0])) {
8035+
8036+ // Ensure the reference do reference the current loop iterator
8037+ // to be tested.
8038+ if (!osl_int_zero(precision, msrc->m[row_k][i])) {
8039+ kp = 1;
8040+ row_kp = candl_util_relation_get_line(mtarg, kp);
8041+
8042+ while (!must_test &&
8043+ kp < mtarg->nb_output_dims &&
8044+ osl_int_zero(precision, mtarg->m[row_kp][0])) {
8045+
8046+ if (!osl_int_zero(precision, mtarg->m[row_kp][j])) {
8047+ // Ensure the access functions are equal for the
8048+ // surrounding loop iterators, and no inner iterator
8049+ // is referenced.
8050+ if (!osl_int_eq(precision,
8051+ msrc->m[row_k][0], mtarg->m[row_kp][0])) {
8052+ must_test = 1;
8053+ } else {
8054+ for (l = 1; l <= i; ++l)
8055+ if (!osl_int_eq(precision,
8056+ msrc->m[row_k][msrc->nb_output_dims + l],
8057+ mtarg->m[row_kp][mtarg->nb_output_dims + l])) {
8058+ must_test = 1;
8059+ break;
8060+ }
8061+ }
8062+ int m = l;
8063+ if (!must_test)
8064+ for (; l <= s_usr->depth+1; ++l)
8065+ if (!osl_int_zero(precision, msrc->m[row_k][msrc->nb_output_dims + l])) {
8066+ must_test = 1;
8067+ break;
8068+ }
8069+ if (!must_test)
8070+ for (; m <= t_usr->depth+1; ++m)
8071+ if (!osl_int_zero(precision, mtarg->m[row_kp][mtarg->nb_output_dims + m])) {
8072+ must_test = 1;
8073+ break;
8074+ }
8075+ if (!must_test)
8076+ for (; l < msrc->nb_columns-1; ++l, ++m)
8077+ if (!osl_int_eq(precision,
8078+ msrc->m[row_k][msrc->nb_output_dims + l],
8079+ mtarg->m[row_kp][mtarg->nb_output_dims + m])) {
8080+ must_test = 1;
8081+ break;
8082+ }
8083+ }
8084+ ++kp;
8085+ row_kp = candl_util_relation_get_line(mtarg, kp);
8086+ }
8087+ }
8088+ ++k;
8089+ row_k = candl_util_relation_get_line(msrc, k);
8090+ }
8091+
8092 if (src_ref_iter && dst_ref_iter && !must_test)
8093 return 0;
8094
8095-
8096 /* Final check. For loop i, the dependence is loop carried if there exists
8097 x_i^R != x_i^S in the dependence polyhedron, with
8098 x_{1..i-1}^R = x_{1..i-1}^S
8099- */
8100+ */
8101 int pos;
8102- CandlMatrix* mat = dep->domain;
8103- CandlStatement* src = dep->source;
8104- CandlMatrix* testsyst =
8105- candl_matrix_malloc(mat->NbRows + 1 + dep->source->depth, mat->NbColumns);
8106- for (pos = 0; pos < mat->NbRows; ++pos)
8107- for (j = 0; j < mat->NbColumns; ++j)
8108- CANDL_assign(testsyst->p[pos][j], mat->p[pos][j]);
8109- for (j = 0; j < i; ++j)
8110- {
8111- CANDL_set_si(testsyst->p[pos + j + 1][0], 0);
8112- CANDL_set_si(testsyst->p[pos + j + 1][1 + j], -1);
8113- CANDL_set_si(testsyst->p[pos + j + 1][1 + j + dep->source->depth], 1);
8114- }
8115+ osl_relation_p mat = dep->domain;
8116+
8117+ osl_relation_p testsyst = osl_relation_pmalloc(precision,
8118+ mat->nb_rows + 1 + s_usr->depth,
8119+ mat->nb_columns);
8120+ for (pos = 0; pos < mat->nb_rows; ++pos)
8121+ for (j = 0; j < mat->nb_columns; ++j)
8122+ osl_int_assign(precision,
8123+ &testsyst->m[pos][j], mat->m[pos][j]);
8124+ for (j = 0; j < i; ++j) {
8125+ osl_int_set_si(precision, &testsyst->m[pos+j+1][0], 0);
8126+ osl_int_set_si(precision, &testsyst->m[pos+j+1][1+j], -1);
8127+ osl_int_set_si(precision, &testsyst->m[pos+j+1][1+j+mat->nb_output_dims], 1);
8128+ }
8129
8130 int has_pt = 0;
8131 // Test for '>'.
8132- CANDL_set_si(testsyst->p[pos][0], 1);
8133- CANDL_set_si(testsyst->p[pos][testsyst->NbColumns - 1], -1);
8134- CANDL_set_si(testsyst->p[pos][1 + i], 1);
8135- CANDL_set_si(testsyst->p[pos][1 + i + src->depth], -1);
8136- has_pt = pip_has_rational_point (testsyst, NULL, 1);
8137- if (! has_pt)
8138- {
8139- // Test for '<'.
8140- CANDL_set_si(testsyst->p[pos][1 + i], -1);
8141- CANDL_set_si(testsyst->p[pos][1 + i + src->depth], 1);
8142- has_pt = pip_has_rational_point (testsyst, NULL, 1);
8143- }
8144-
8145- candl_matrix_free (testsyst);
8146-
8147+ osl_int_set_si(precision, &testsyst->m[pos][0], 1);
8148+ osl_int_set_si(precision, &testsyst->m[pos][testsyst->nb_columns-1], -1);
8149+ osl_int_set_si(precision, &testsyst->m[pos][1+i], 1);
8150+ osl_int_set_si(precision, &testsyst->m[pos][1+i+mat->nb_output_dims], -1);
8151+
8152+ has_pt = pip_has_rational_point(testsyst, NULL, 1);
8153+ if (!has_pt) {
8154+ // Test for '<'.
8155+ osl_int_set_si(precision, &testsyst->m[pos][1+i], -1);
8156+ osl_int_set_si(precision, &testsyst->m[pos][1+i+mat->nb_output_dims], 1);
8157+ has_pt = pip_has_rational_point(testsyst, NULL, 1);
8158+ }
8159+
8160 return has_pt;
8161
8162- /* LNP: OLD VERSION. The above is more robust. */
8163-/* /\* Final check. The dependence exists only because the loop */
8164-/* iterates. Make the loop not iterate and check if there's still */
8165-/* dependent iterations. *\/ */
8166-/* CandlMatrix* m = candl_matrix_malloc(dep->domain->NbRows + 2, */
8167-/* dep->domain->NbColumns); */
8168-/* CANDL_set_si(m->p[m->NbRows - 2][i + 1], -1); */
8169-/* CANDL_set_si(m->p[m->NbRows - 1][dep->source->depth + 1 + j], -1); */
8170-/* /\* Copy the rest of the matrix. *\/ */
8171-/* int ii, jj; */
8172-/* for (ii = 0; ii < dep->domain->NbRows; ++ii) */
8173-/* for (jj = 0; jj < dep->domain->NbColumns; ++jj) */
8174-/* CANDL_assign(m->p[ii][jj], dep->domain->p[ii][jj]); */
8175-/* /\* Compute real lb of loops. *\/ */
8176-/* Entier lb; CANDL_init(lb); */
8177-/* candl_dependence_compute_lb (m, &lb, i + 1); */
8178-/* CANDL_assign(m->p[m->NbRows - 2][m->NbColumns - 1], lb); */
8179-/* candl_dependence_compute_lb (m, &lb, dep->source->depth + 1 + j); */
8180-/* CANDL_assign(m->p[m->NbRows - 1][m->NbColumns - 1], lb); */
8181-/* int ret = candl_matrix_check_point(m, program->context); */
8182-/* CANDL_clear(lb); */
8183-
8184-/* /\* Be clean. *\/ */
8185-/* candl_matrix_free(m); */
8186-
8187-/* return !ret; */
8188+ /* LNP: OLD VERSION */
8189+ /* The above is more robust. */
8190+ /* /\* Final check. The dependence exists only because the loop */
8191+ /* iterates. Make the loop not iterate and check if there's still */
8192+ /* dependent iterations. *\/ */
8193+ /* CandlMatrix* m = candl_matrix_malloc(dep->domain->NbRows + 2, */
8194+ /* dep->domain->NbColumns); */
8195+ /* CANDL_set_si(m->p[m->NbRows - 2][i + 1], -1); */
8196+ /* CANDL_set_si(m->p[m->NbRows - 1][dep->source->depth + 1 + j], -1); */
8197+ /* /\* Copy the rest of the matrix. *\/ */
8198+ /* int ii, jj; */
8199+ /* for (ii = 0; ii < dep->domain->NbRows; ++ii) */
8200+ /* for (jj = 0; jj < dep->domain->NbColumns; ++jj) */
8201+ /* CANDL_assign(m->p[ii][jj], dep->domain->p[ii][jj]); */
8202+ /* /\* Compute real lb of loops. *\/ */
8203+ /* Entier lb; CANDL_init(lb); */
8204+ /* candl_dependence_compute_lb (m, &lb, i + 1); */
8205+ /* CANDL_assign(m->p[m->NbRows - 2][m->NbColumns - 1], lb); */
8206+ /* candl_dependence_compute_lb (m, &lb, dep->source->depth + 1 + j); */
8207+ /* CANDL_assign(m->p[m->NbRows - 1][m->NbColumns - 1], lb); */
8208+ /* int ret = candl_matrix_check_point(m, program->context); */
8209+ /* CANDL_clear(lb); */
8210+
8211+ /* /\* Be clean. *\/ */
8212+ /* candl_matrix_free(m); */
8213+
8214+ /* return !ret; */
8215 }
8216
8217
8218@@ -2178,98 +1814,100 @@ candl_dependence_is_loop_carried (candl_program_p program,
8219 * prunes the dependence graph 'deps' by removing loop-carried
8220 * dependences involving a scalar variable privatizable for that loop.
8221 */
8222-void
8223-candl_dependence_prune_with_privatization (candl_program_p program,
8224- CandlOptions* options,
8225- CandlDependence** deps)
8226-{
8227- CandlDependence* next;
8228- CandlDependence* tmp;
8229- CandlDependence* pred = NULL;
8230+void candl_dependence_prune_with_privatization(osl_scop_p scop,
8231+ candl_options_p options,
8232+ osl_dependence_p* deps) {
8233+ osl_dependence_p next;
8234+ osl_dependence_p tmp;
8235+ osl_dependence_p pred = NULL;
8236+ candl_statement_usr_p s_usr;
8237+ candl_statement_usr_p t_usr;
8238+ candl_scop_usr_p scop_usr = scop->usr;
8239 int is_priv;
8240- int i, j;
8241+ int i;
8242+ int row;
8243 int loop_idx = 0;
8244 int refs, reft;
8245 int loop_pos_priv;
8246-
8247+ int precision = scop->context->precision;
8248
8249 if (options->verbose)
8250 fprintf (stderr, "[Candl] Scalar Analysis: Remove loop-carried dependences"
8251- " on privatizable scalars\n");
8252+ " on privatizable scalars\n");
8253
8254- if (program->nb_statements == 0)
8255+ if (scop->statement == NULL)
8256 return;
8257+
8258 /* Perform the scalar analysis, if not done before. */
8259- if (program->scalars_privatizable == NULL)
8260- {
8261- CandlOptions* options = candl_options_malloc ();
8262- options->scalar_privatization = 1;
8263- candl_dependence_analyze_scalars (program, options);
8264- candl_options_free (options);
8265+ if (scop_usr->scalars_privatizable == NULL) {
8266+ candl_options_p options = candl_options_malloc();
8267+ options->scalar_privatization = 1;
8268+ candl_dependence_analyze_scalars(scop, options);
8269+ candl_options_free(options);
8270+ }
8271+
8272+ for (tmp = *deps; tmp; ) {
8273+ s_usr = tmp->stmt_source_ptr->usr;
8274+ t_usr = tmp->stmt_target_ptr->usr;
8275+
8276+ /* Check if the dependence is involving a privatizable scalar. */
8277+ is_priv = 1;
8278+ candl_dependence_get_array_refs_in_dep(tmp, &refs, &reft);
8279+ for (i = 0; i < s_usr->depth; ++i) {
8280+ if (candl_dependence_scalar_is_privatizable_at(scop, refs,
8281+ s_usr->index[i]))
8282+ break;
8283 }
8284-
8285- for (tmp = *deps; tmp; )
8286- {
8287- /* Check if the dependence is involving a privatizable scalar. */
8288- is_priv = 1;
8289- candl_dependence_get_array_refs_in_dep (tmp, &refs, &reft);
8290- for (i = 0; i < tmp->source->depth; ++i)
8291- if (candl_dependence_scalar_is_privatizable_at (program, refs,
8292- tmp->source->index[i]))
8293- break;
8294- if (i == tmp->source->depth)
8295- {
8296- for (i = 0; i < tmp->target->depth; ++i)
8297- if (candl_dependence_scalar_is_privatizable_at
8298- (program, reft, tmp->target->index[i]))
8299- break;
8300- if (i == tmp->target->depth)
8301- is_priv = 0;
8302- else
8303- loop_idx = tmp->target->index[i];
8304- }
8305+ if (i == s_usr->depth) {
8306+ for (i = 0; i < t_usr->depth; ++i) {
8307+ if (candl_dependence_scalar_is_privatizable_at
8308+ (scop, reft, t_usr->index[i]))
8309+ break;
8310+ }
8311+ if (i == t_usr->depth)
8312+ is_priv = 0;
8313 else
8314- loop_idx = tmp->source->index[i];
8315- loop_pos_priv = i;
8316- /* Check if the dependence is loop-carried at loop i. */
8317- if (is_priv && candl_dependence_is_loop_carried (program, tmp, loop_idx))
8318- {
8319- /* If so, make the dependence loop-independent. */
8320- CandlMatrix* m = candl_matrix_malloc (tmp->domain->NbRows + 1,
8321- tmp->domain->NbColumns);
8322- for (i = 0; i < tmp->domain->NbRows; ++i)
8323- for (j = 0; j < tmp->domain->NbColumns; ++j)
8324- CANDL_assign(m->p[i][j], tmp->domain->p[i][j]);
8325- candl_matrix_free (tmp->domain);
8326- tmp->domain = m;
8327- CANDL_set_si(tmp->domain->p[tmp->domain->NbRows - 1]
8328- [1 + loop_pos_priv], 1);
8329- CANDL_set_si(tmp->domain->p[tmp->domain->NbRows - 1]
8330- [1 + loop_pos_priv + tmp->source->depth], -1);
8331- /* Set the type of the dependence as special
8332- scalar-privatization one. */
8333- if (tmp->type == CANDL_RAW)
8334- tmp->type = CANDL_RAW_SCALPRIV;
8335- next = tmp->next;
8336- if (!candl_matrix_check_point (tmp->domain, NULL))
8337- {
8338- /* It is, the dependence can be removed. */
8339- candl_matrix_free (tmp->domain);
8340- if (pred == NULL)
8341- *deps = next;
8342- else
8343- pred->next = next;
8344- free (tmp);
8345- }
8346- pred = tmp;
8347- tmp = next;
8348-
8349- continue;
8350- }
8351- /* Go to the next victim. */
8352+ loop_idx = t_usr->index[i];
8353+ } else {
8354+ loop_idx = s_usr->index[i];
8355+ }
8356+ loop_pos_priv = i;
8357+
8358+ /* Check if the dependence is loop-carried at loop i. */
8359+ if (is_priv && candl_dependence_is_loop_carried(scop, tmp, loop_idx)) {
8360+ /* If so, make the dependence loop-independent. */
8361+ row = tmp->domain->nb_rows;
8362+ osl_relation_insert_blank_row(tmp->domain, row);
8363+ osl_int_set_si(precision,
8364+ &tmp->domain->m[row][1 + loop_pos_priv],
8365+ 1);
8366+ osl_int_set_si(precision,
8367+ &tmp->domain->m[row][1 + loop_pos_priv + s_usr->depth],
8368+ -1);
8369+
8370+ /* Set the type of the dependence as special
8371+ scalar-privatization one. */
8372+ if (tmp->type == OSL_DEPENDENCE_RAW)
8373+ tmp->type = OSL_DEPENDENCE_RAW_SCALPRIV;
8374+ next = tmp->next;
8375+ if (!candl_matrix_check_point(tmp->domain, NULL)) {
8376+ /* It is, the dependence can be removed. */
8377+ osl_relation_free(tmp->domain);
8378+ if (pred == NULL)
8379+ *deps = next;
8380+ else
8381+ pred->next = next;
8382+ free(tmp);
8383+ }
8384 pred = tmp;
8385- tmp = tmp->next;
8386+ tmp = next;
8387+
8388+ continue;
8389 }
8390+ /* Go to the next victim. */
8391+ pred = tmp;
8392+ tmp = tmp->next;
8393+ }
8394 }
8395
8396
8397@@ -2278,27 +1916,29 @@ candl_dependence_prune_with_privatization (candl_program_p program,
8398 * This function checks if a given scalar 'var_index' is privatizable
8399 * for loop 'loop_index'.
8400 */
8401-int
8402-candl_dependence_scalar_is_privatizable_at (candl_program_p program,
8403- int var_index,
8404- int loop_index)
8405-{
8406+int candl_dependence_scalar_is_privatizable_at(osl_scop_p scop,
8407+ int var_index,
8408+ int loop_index) {
8409+ candl_scop_usr_p scop_usr = scop->usr;
8410 int i;
8411
8412 /* If the scalar analysis wasn't performed yet, do it. */
8413- if (program->scalars_privatizable == NULL)
8414- {
8415- CandlOptions* options = candl_options_malloc();
8416- options->scalar_privatization = 1;
8417- candl_dependence_analyze_scalars (program, options);
8418- candl_options_free (options);
8419- }
8420+ if (scop_usr->scalars_privatizable == NULL) {
8421+ candl_options_p options = candl_options_malloc();
8422+ options->scalar_privatization = 1;
8423+ candl_dependence_analyze_scalars(scop, options);
8424+ candl_options_free(options);
8425+ }
8426+
8427+ i = 0;
8428+ while (scop_usr->scalars_privatizable[i] != -1)
8429+ i++;
8430
8431 /* Check in the array of privatizable scalar variables for the tuple
8432 (var,loop). */
8433- for (i = 0; program->scalars_privatizable[i] != -1; i += 2)
8434- if (program->scalars_privatizable[i] == var_index &&
8435- program->scalars_privatizable[i + 1] == loop_index)
8436+ for (i = 0; scop_usr->scalars_privatizable[i] != -1; i += 2)
8437+ if (scop_usr->scalars_privatizable[i] == var_index &&
8438+ scop_usr->scalars_privatizable[i + 1] == loop_index)
8439 return 1;
8440
8441 return 0;
8442@@ -2307,320 +1947,222 @@ candl_dependence_scalar_is_privatizable_at (candl_program_p program,
8443
8444 /**
8445 * candl_dependence_analyze_scalars function:
8446- * This function checks, for all scalar variables of the program, and
8447+ * This function checks, for all scalar variables of the scop, and
8448 * all loop levels, if the scalar can be privatized at that level.
8449 */
8450-int
8451-candl_dependence_analyze_scalars(candl_program_p program,
8452- CandlOptions* options)
8453-{
8454+int candl_dependence_analyze_scalars(osl_scop_p scop,
8455+ candl_options_p options) {
8456 int* scalars;
8457- CandlStatement** stmts;
8458- CandlStatement** fullchain = NULL;
8459- int i, j, k, l, n;
8460- CandlMatrix* m;
8461- int max, is_priv, cpt, offset, was_priv;
8462- CandlStatement* curlast;
8463- CandlStatement* last;
8464+ osl_statement_p* statement; /* not a chained list, but an array of */
8465+ osl_statement_p* fullchain; /* statement to not realloc the usr field */
8466+ osl_statement_p s;
8467+ osl_statement_p curlast;
8468+ osl_statement_p last;
8469+ osl_statement_p iter; /* used to iterate on the scop */
8470+ osl_relation_list_p access;
8471+ osl_relation_p elt;
8472+ candl_scop_usr_p scop_usr = scop->usr;
8473+ candl_statement_usr_p stmt_usr;
8474+ int i, j, k;
8475+ int max, is_priv, offset, was_priv;
8476 int nb_priv = 0;
8477 int priv_buff_size = 64;
8478+ int id, row;
8479
8480 /* Initialize the list of privatizable scalars to empty. */
8481- if (options->scalar_privatization)
8482- {
8483- program->scalars_privatizable = (int*) malloc(2 * sizeof(int));
8484- program->scalars_privatizable[0] = program->scalars_privatizable[1] = -1;
8485- }
8486+ if (options->scalar_privatization) {
8487+ CANDL_malloc(scop_usr->scalars_privatizable, int*, 2 * sizeof(int));
8488+ scop_usr->scalars_privatizable[0] = -1;
8489+ scop_usr->scalars_privatizable[1] = -1;
8490+ }
8491
8492 /* Retrieve all scalar variables. */
8493- scalars = candl_dependence_extract_scalar_variables (program);
8494+ scalars = candl_dependence_extract_scalar_variables(scop);
8495
8496 /* For each of those, detect (at any level) if it can be privatized
8497 / expanded / renamed. */
8498- for (i = 0; scalars[i] != -1; ++i)
8499- {
8500- /* Go to the first statement referencing the scalar. */
8501- for (j = 0; j < program->nb_statements; ++j)
8502- if (candl_dependence_var_is_ref (program->statement[j], scalars[i])
8503- != CANDL_VAR_UNDEF)
8504- break;
8505- /* A weird error occured. */
8506- if (j == program->nb_statements)
8507- continue;
8508-
8509- /* Take all statements referencing the scalar. */
8510- fullchain = candl_dependence_refvar_chain (program, program->statement[j],
8511- scalars[i], 0);
8512- /* Compute the maximum loop depth of the chain. */
8513- for (k = 0, max = 0; fullchain[k]; ++k)
8514- max = max < fullchain[k]->depth ? fullchain[k]->depth : max;
8515- last = fullchain[k - 1];
8516- /* Initialize the offset for expansion. */
8517- offset = 0;
8518- was_priv = 0;
8519- /* Iterate on all possible depth for analysis. */
8520- for (k = 1; k <= max; ++k)
8521- {
8522- CandlStatement* s = fullchain[0];
8523- if (was_priv)
8524- {
8525- ++offset;
8526- was_priv = 0;
8527- }
8528- do
8529- {
8530- /* Take all statements dominated by s referencing the
8531- current scalar variable. */
8532- stmts = candl_dependence_refvar_chain (program, s, scalars[i], k);
8533- /* No more statement in the chain, exit. */
8534- if (stmts[0] == NULL)
8535- break;
8536- int c = 0;
8537- is_priv = candl_dependence_var_is_ref (stmts[c], scalars[i])
8538- == CANDL_VAR_IS_DEF;
8539- /* Ensure we have a use in the chain. */
8540- for (l = c + 1; stmts[l - 1] && stmts[l]; ++l)
8541- if (candl_dependence_var_is_ref (stmts[l], scalars[i]) ==
8542- CANDL_VAR_IS_USED)
8543- break;
8544- if (stmts[l - 1] == NULL || stmts[l] == NULL)
8545- is_priv = 0;
8546- /* Check for privatization, while the entry of the chain
8547- is a DEF. */
8548- while (stmts[c] && candl_dependence_var_is_ref
8549- (stmts[c], scalars[i]) == CANDL_VAR_IS_DEF)
8550- {
8551- /* From the current DEF node, ensure the rest of the
8552- chain covers not more than the iteration domain
8553- of the DEF. */
8554- for (l = c + 1; stmts[l - 1] && stmts[l]; ++l)
8555- /* FIXME: we should deal with
8556- def_1->use->def_2->use chains where dom(def_2)
8557- > dom(def_1). */
8558- if (! candl_dependence_check_domain_is_included
8559- (stmts[c], stmts[l], program->context, k))
8560- {
8561- /* dom(use) - dom(def) > 0. Check if there is
8562- another DEF to test at the entry of the
8563- block. */
8564- if (stmts[c + 1])
8565- if (candl_dependence_var_is_ref
8566- (stmts[c + 1], scalars[i]) != CANDL_VAR_IS_DEF)
8567- /* No. The variable is not privatizable. */
8568- is_priv = 0;
8569- break;
8570- }
8571- if (! is_priv || ! stmts[l])
8572- break;
8573- /* The chain dominated by stmts[c] is not
8574- privatizable. Go for the next DEF at the
8575- beginning of the block, if any. */
8576- ++c;
8577- }
8578- if (is_priv)
8579- {
8580- /* Perform the privatization / expansion. */
8581- if (options->verbose)
8582- fprintf (stderr, "[Candl] Scalar Analysis: The variable %d"
8583- " can be privatized at loop %d\n",
8584- scalars[i], stmts[0]->index[k - 1]);
8585- if (options->scalar_expansion)
8586- /* Traverse all statements in the chain. */
8587- for (l = c; stmts[l]; ++l)
8588- {
8589- /* It's not the first expansion of the scalar,
8590- we need to increase its dimension all along
8591- the program. */
8592- if (offset && !was_priv)
8593- candl_dependence_expand_scalar (fullchain,
8594- scalars[i]);
8595- /* Perform scalar expansion in the array
8596- access functions. */
8597- for (cpt = 0, m = stmts[l]->read; cpt < 2;
8598- ++cpt, m = stmts[l]->written)
8599- for (n = 0; n < m->NbRows; ++n)
8600- if (CANDL_get_si(m->p[n][0]) == scalars[i])
8601- CANDL_set_si(m->p[n + offset][k], 1);
8602- was_priv = 1;
8603- }
8604- if (options->scalar_privatization)
8605- {
8606- /* Memory management for the array of
8607- privatizable scalars. */
8608- if (nb_priv == 0)
8609- {
8610- free (program->scalars_privatizable);
8611- program->scalars_privatizable =
8612- (int*)malloc(priv_buff_size * sizeof(int));
8613- for (l = 0; l < priv_buff_size; ++l)
8614- program->scalars_privatizable[l] = -1;
8615- }
8616- if (nb_priv == priv_buff_size)
8617- {
8618- program->scalars_privatizable =
8619- realloc(program->scalars_privatizable,
8620- (priv_buff_size *= 2) * sizeof(int));
8621- for (l = nb_priv; l < priv_buff_size; ++l)
8622- program->scalars_privatizable[l] = -1;
8623- }
8624- /* Memorize the scalar information in the
8625- privatizable list. */
8626- program->scalars_privatizable[nb_priv++] = scalars[i];
8627- program->scalars_privatizable[nb_priv++] =
8628- stmts[0]->index[k - 1];
8629- }
8630- }
8631- /* Go to the next block, if any. */
8632- for (l = 0; stmts[l]; ++l)
8633- ;
8634- curlast = stmts[l - 1];
8635- if (curlast != last)
8636- {
8637- for (l = 0; fullchain[l]; ++l)
8638- if (fullchain[l] == curlast)
8639- s = fullchain[l + 1];
8640- }
8641- free (stmts);
8642- }
8643- while (curlast != last);
8644- }
8645- free (fullchain);
8646+ for (i = 0; scalars[i] != -1; ++i) {
8647+ /* Go to the first statement referencing the scalar in the scop. */
8648+ for (iter = scop->statement; iter != NULL; iter = iter->next) {
8649+ if (candl_dependence_var_is_ref(iter, scalars[i])
8650+ != CANDL_VAR_UNDEF)
8651+ break;
8652 }
8653-
8654- return 0;
8655-}
8656-
8657-
8658-/**
8659- * candl_num_dependences function:
8660- * This function returns the number of dependences in the dependence
8661- * list
8662- * \param dependence The first dependence of the dependence list.
8663- **
8664- */
8665-int
8666-candl_num_dependences(CandlDependence *candl_deps)
8667-{
8668- CandlDependence *candl_dep = candl_deps;
8669-
8670- int num = 0;
8671- while (candl_dep != NULL)
8672- {
8673- num++;
8674- candl_dep = candl_dep->next;
8675+
8676+ /* A weird error occured. */
8677+ if (iter == NULL)
8678+ continue;
8679+
8680+ /* Take all statements referencing the scalar. */
8681+ fullchain = candl_dependence_refvar_chain(scop, iter, scalars[i], 0);
8682+
8683+ /* Compute the maximum loop depth of the chain. */
8684+ max = 0;
8685+ for (k = 0; fullchain[k]; ++k) {
8686+ stmt_usr = fullchain[k]->usr;
8687+ if (max < stmt_usr->depth)
8688+ max = stmt_usr->depth;
8689 }
8690- return num;
8691-}
8692-
8693-
8694-/*
8695- * Convert a PIP quast to a union of polyhedra (Pip matrices)
8696- *
8697- * num: number of Pip matrices returned
8698- *
8699- **/
8700-static
8701-PipMatrix **quast_to_polyhedra (PipQuast *quast, int *num,
8702- int nvar, int npar)
8703-{
8704- int num1, num2;
8705- PipMatrix** ep;
8706- PipMatrix** tp;
8707- PipMatrix** qp;
8708- int i, j;
8709- if (quast == NULL)
8710- {
8711- *num = 0;
8712- return NULL;
8713- }
8714-
8715- if (quast->condition != NULL)
8716- {
8717- tp = quast_to_polyhedra(quast->next_then, &num1, nvar, npar);
8718- ep = quast_to_polyhedra(quast->next_else, &num2, nvar, npar);
8719-
8720- /* Each of the matrices in the then tree needs to be augmented with
8721- * the condition */
8722- for (i = 0; i < num1; i++)
8723- {
8724- int nrows = tp[i]->NbRows;
8725- CANDL_set_si(tp[i]->p[nrows][0], 1);
8726- for (j = 1; j < 1 + nvar; j++)
8727- CANDL_set_si(tp[i]->p[nrows][j], 0);
8728- for (j = 0; j < npar + 1; j++)
8729- CANDL_assign(tp[i]->p[nrows][1+nvar+j],
8730- quast->condition->the_vector[j]);
8731- (tp[i]->NbRows)++;
8732- }
8733-
8734- for (i = 0; i < num2; i++)
8735- {
8736- int nrows = ep[i]->NbRows;
8737- /* Inequality */
8738- CANDL_set_si(ep[i]->p[nrows][0], 1);
8739- for (j = 1; j < 1 + nvar; j++)
8740- CANDL_set_si(ep[i]->p[nrows][j], 0);
8741- for (j = 0; j < npar + 1; j++)
8742- CANDL_set_si(ep[i]->p[nrows][1+nvar+j],
8743- -CANDL_get_si(quast->condition->the_vector[j]));
8744- (ep[i]->NbRows)++;
8745- }
8746-
8747- qp = (PipMatrix **) malloc((num1 + num2) * sizeof(PipMatrix*));
8748- for (i = 0; i < num1; ++i)
8749- qp[i] = tp[i];
8750- for (i = 0; i < num2; ++i)
8751- qp[i + num1] = ep[i];
8752-
8753- *num = num1 + num2;
8754-
8755- return qp;
8756-
8757+ last = fullchain[k-1];
8758+
8759+ /* Initialize the offset for expansion. */
8760+ offset = 0;
8761+ was_priv = 0;
8762+
8763+ /* Iterate on all possible depth for analysis. */
8764+ for (j = 1; j <= max; ++j) {
8765+ s = fullchain[0];
8766+
8767+ if (was_priv) {
8768+ ++offset;
8769+ was_priv = 0;
8770 }
8771- else
8772- {
8773- /* quast condition is NULL */
8774- PipMatrix *lwmatrix = pip_matrix_alloc(nvar+npar+1, nvar+npar+2);
8775-
8776- PipList *vecList = quast->list;
8777-
8778- int count=0;
8779- while (vecList != NULL) {
8780- /* Equality */
8781- CANDL_set_si(lwmatrix->p[count][0], 0);
8782- for (j=0; j<nvar; j++)
8783- if (j == count)
8784- CANDL_set_si(lwmatrix->p[count][j+1], 1);
8785- else
8786- CANDL_set_si(lwmatrix->p[count][j+1], 0);
8787-
8788- for (j=0; j<npar; j++)
8789- CANDL_set_si(lwmatrix->p[count][j+1+nvar],
8790- -CANDL_get_si(vecList->vector->the_vector[j]));
8791- /* Constant portion */
8792- if (quast->newparm != NULL)
8793- /* Don't handle newparm for now */
8794- CANDL_set_si(lwmatrix->p[count][npar+1+nvar],
8795- -CANDL_get_si(vecList->vector->the_vector[npar+1]));
8796- else
8797- CANDL_set_si(lwmatrix->p[count][npar+1+nvar],
8798- -CANDL_get_si(vecList->vector->the_vector[npar]));
8799-
8800- count++;
8801-
8802- vecList = vecList->next;
8803+
8804+ do {
8805+ /* Take all statements dominated by s referencing the
8806+ current scalar variable. */
8807+ statement = candl_dependence_refvar_chain(scop, s, scalars[i], j);
8808+
8809+ /* No more statement in the chain, exit. */
8810+ if (statement[0] == NULL) {
8811+ free(statement);
8812+ break;
8813 }
8814- lwmatrix->NbRows = count;
8815-
8816- if (count > 0)
8817- *num = 1;
8818- else
8819- *num = 0;
8820+
8821+ int c = 0;
8822+
8823+ is_priv = candl_dependence_var_is_ref(statement[0], scalars[i]) ==
8824+ CANDL_VAR_IS_DEF;
8825+
8826+ /* Ensure we have a use in the chain. */
8827+ /* here statement[c] is not NULL */
8828+ for (k = c + 1; statement[k]; ++k) {
8829+ if (candl_dependence_var_is_ref(statement[k], scalars[i]) ==
8830+ CANDL_VAR_IS_USED)
8831+ break;
8832+ }
8833+
8834+ if (statement[k] == NULL)
8835+ is_priv = 0;
8836+
8837+ /* Check for privatization, while the entry of the chain
8838+ is a DEF. */
8839+ while (statement[c] && candl_dependence_var_is_ref
8840+ (statement[c], scalars[i]) == CANDL_VAR_IS_DEF) {
8841+ /* From the current DEF node, ensure the rest of the
8842+ chain covers not more than the iteration domain
8843+ of the DEF. */
8844+ for (k = c + 1; statement[k]; ++k) {
8845+ /* FIXME: we should deal with
8846+ def_1->use->def_2->use chains where dom(def_2)
8847+ > dom(def_1). */
8848+ if (! candl_dependence_check_domain_is_included
8849+ (statement[c], statement[k], scop->context, j)) {
8850+ /* dom(use) - dom(def) > 0. Check if there is
8851+ another DEF to test at the entry of the
8852+ block. */
8853+ if (candl_dependence_var_is_ref
8854+ (statement[c+1], scalars[i]) != CANDL_VAR_IS_DEF)
8855+ /* No. The variable is not privatizable. */
8856+ is_priv = 0;
8857+ break;
8858+ }
8859+ }
8860+
8861+ if (! is_priv || ! statement[k])
8862+ break;
8863+
8864+ /* The chain dominated by statement is not
8865+ privatizable. Go for the next DEF at the
8866+ beginning of the block, if any. */
8867+ ++c;
8868+ }
8869+
8870+ if (is_priv) {
8871+ /* Perform the privatization / expansion. */
8872+ if (options->verbose)
8873+ fprintf(stderr, "[Candl] Scalar Analysis: The variable %d"
8874+ " can be privatized at loop %d\n",
8875+ scalars[i],
8876+ ((candl_statement_usr_p)statement[0]->usr)->index[j-1]);
8877+
8878+ if (options->scalar_expansion) {
8879+ int precision = scop->context->precision;
8880+ /* Traverse all statements in the chain. */
8881+ for (k = c; statement[k]; ++k) {
8882+ /* It's not the first expansion of the scalar,
8883+ we need to increase its dimension all along
8884+ the program. */
8885+ if (!offset && !was_priv)
8886+ candl_dependence_expand_scalar(fullchain,
8887+ scalars[i]);
8888+ /* Perform scalar expansion in the array
8889+ access functions. */
8890+ access = statement[k]->access;
8891+ for (; access != NULL; access = access->next) {
8892+ elt = access->elt;
8893+ id = osl_relation_get_array_id(elt);
8894+ if (scalars[i] == id) {
8895+ row = candl_util_relation_get_line(elt, offset+1);
8896+ osl_int_set_si(precision, &elt->m[row][elt->nb_output_dims + j], 1);
8897+ }
8898+ }
8899+ was_priv = 1;
8900+ }
8901+ }
8902+
8903+ if (options->scalar_privatization) {
8904+ /* Memory management for the array of
8905+ privatizable scalars. */
8906+ if (nb_priv == 0) {
8907+ free(scop_usr->scalars_privatizable);
8908+ CANDL_malloc(scop_usr->scalars_privatizable,
8909+ int*, priv_buff_size * sizeof(int));
8910+ for (k = 0; k < priv_buff_size; ++k)
8911+ scop_usr->scalars_privatizable[k] = -1;
8912+ }
8913+
8914+ if (nb_priv == priv_buff_size) {
8915+ CANDL_realloc(scop_usr->scalars_privatizable,
8916+ int*, (priv_buff_size *= 2) * sizeof(int));
8917+ for (k = nb_priv; k < priv_buff_size; ++k)
8918+ scop_usr->scalars_privatizable[k] = -1;
8919+ }
8920+
8921+ /* Memorize the scalar information in the
8922+ privatizable list. */
8923+ scop_usr->scalars_privatizable[nb_priv++] = scalars[i];
8924+ scop_usr->scalars_privatizable[nb_priv++] =
8925+ ((candl_statement_usr_p)statement[0]->usr)->index[j - 1];
8926+ }
8927+
8928+ } // end is_priv
8929+
8930+
8931+ /* Go to the next block, if any. */
8932+ for (k = 0; statement[k]; ++k)
8933+ ;
8934+ curlast = statement[k-1];
8935+
8936+ if (curlast != last) {
8937+ for (k = 0; fullchain[k]; ++k) {
8938+ if (fullchain[k] == curlast) {
8939+ s = fullchain[k+1];
8940+ break;
8941+ }
8942+ }
8943+ }
8944+ free(statement);
8945+
8946+ } while (curlast != last);
8947+
8948+ } // end iterate all possible depth
8949+
8950+ free(fullchain);
8951+
8952+ } // end iterate scalars
8953
8954- PipMatrix** ret = (PipMatrix**) malloc(sizeof(PipMatrix*));
8955- ret[0] = lwmatrix;
8956- return ret;
8957- }
8958+ return 0;
8959 }
8960
8961
8962@@ -2631,119 +2173,142 @@ PipMatrix **quast_to_polyhedra (PipQuast *quast, int *num,
8963 * Returns 0 if lastwriter is computed successfully and dep domain updated,
8964 * returns 1 otherwise
8965 */
8966-static
8967-int candl_dep_compute_lastwriter (CandlDependence **dep, CandlProgram *prog)
8968-{
8969- PipQuast *lexmax;
8970- PipMatrix *new_domain;
8971-
8972- int i, j;
8973-
8974- int npar = prog->context->NbColumns-2;
8975-
8976- PipOptions *pipOptions = pip_options_init();
8977-
8978- /* We do a parametric lexmax on the source iterators
8979- * keeping the target iterators as parameters */
8980- pipOptions->Maximize = 1;
8981- pipOptions->Simplify = 1;
8982- // pipOptions->Deepest_cut = 1;
8983- // pipOptions->Urs_unknowns = -1;
8984- // pipOptions->Urs_parms = -1;
8985-
8986- /* Build a context with equalities /inequalities only on the target
8987- * variables */
8988- PipMatrix *context = pip_matrix_alloc((*dep)->domain->NbRows,
8989- (*dep)->target->depth + npar + 2);
8990-
8991- int nrows = 0;
8992- for (i = 0; i < (*dep)->domain->NbRows; i++)
8993- {
8994- for (j = 1; j < (*dep)->source->depth+1; j++)
8995- {
8996- if ((*dep)->domain->p[i][j] != 0)
8997- break;
8998- }
8999- if (j == (*dep)->source->depth+1)
9000- {
9001- /* Include this in the context */
9002- CANDL_assign(context->p[nrows][0], (*dep)->domain->p[i][0]);
9003- for (j = 1; j < 1 + (*dep)->target->depth + npar + 1; j++)
9004- CANDL_assign(context->p[nrows][j],
9005- (*dep)->domain->p[i][(*dep)->source->depth+j]);
9006-
9007- nrows++;
9008- }
9009- }
9010- context->NbRows = nrows;
9011+static
9012+int candl_dep_compute_lastwriter(osl_dependence_p *dep, osl_scop_p scop) {
9013+ PipQuast *lexmax;
9014+ PipOptions *pipOptions = pip_options_init();
9015+ candl_statement_usr_p s_usr = (*dep)->stmt_source_ptr->usr;
9016+ candl_statement_usr_p t_usr = (*dep)->stmt_target_ptr->usr;
9017+ osl_relation_p new_domain;
9018+ int i, j;
9019+ int npar = scop->context->nb_parameters;
9020+ int precision;
9021+
9022+ #if defined(CANDL_LINEAR_VALUE_IS_INT)
9023+ precision = OSL_PRECISION_SP;
9024+ #elif defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
9025+ precision = OSL_PRECISION_DP;
9026+ #elif defined(CANDL_LINEAR_VALUE_IS_MP)
9027+ precision = OSL_PRECISION_MP;
9028+ #endif
9029+
9030+ if (precision != scop->context->precision) {
9031+ CANDL_error("Precision not compatible with piplib ! (pip_relation2matrix)");
9032+ }
9033
9034- /* Parameteric lexmax */
9035- lexmax = pip_solve((*dep)->domain, context, -1, pipOptions);
9036+ /* We do a parametric lexmax on the source iterators
9037+ * keeping the target iterators as parameters */
9038+ pipOptions->Maximize = 1;
9039+ pipOptions->Simplify = 1;
9040+ // pipOptions->Deepest_cut = 1;
9041+ // pipOptions->Urs_unknowns = -1;
9042+ // pipOptions->Urs_parms = -1;
9043+
9044+ /* Build a context with equalities /inequalities only on the target
9045+ * variables */
9046+ osl_relation_p context = osl_relation_pmalloc(precision,
9047+ (*dep)->domain->nb_rows,
9048+ (*dep)->stmt_target_ptr->domain->nb_columns);
9049+ int nrows = 0;
9050+ for (i = 0; i < (*dep)->domain->nb_rows; i++) {
9051+ for (j = 1; j < s_usr->depth+1; j++) {
9052+
9053+ // FIXME : new domain structure for dependence
9054+
9055+ if (!osl_int_zero(precision, (*dep)->domain->m[i][j]))
9056+ break;
9057+ }
9058+
9059+ if (j == t_usr->depth+1) {
9060+ /* Include this in the context */
9061+ osl_int_assign(precision,
9062+ &context->m[nrows][0], (*dep)->domain->m[i][0]);
9063+
9064+ for (j = 1; j < (*dep)->stmt_target_ptr->domain->nb_columns; j++)
9065+ osl_int_assign(precision,
9066+ &context->m[nrows][j],
9067+ (*dep)->domain->m[i][s_usr->depth+j]);
9068+
9069+ nrows++;
9070+ }
9071+ }
9072
9073- pip_options_free(pipOptions);
9074+ /* Parameteric lexmax */
9075+ lexmax = pip_solve_osl((*dep)->domain, context, -1, pipOptions);
9076
9077- if (lexmax == NULL)
9078- {
9079- printf("WARNING: last writer failed (mostly invalid dependence): %s\n",
9080- "bailing out safely without modification");
9081- pip_matrix_print(stdout, (*dep)->domain);
9082- pip_matrix_print(stdout, context);
9083- return 1;
9084- }
9085+ pip_options_free(pipOptions);
9086+
9087+ if (lexmax == NULL) {
9088+ CANDL_warning("last writer failed (mostly invalid dependence): bailing out"
9089+ "safely without modification");
9090+ osl_relation_print(stderr, context);
9091+ osl_relation_print(stderr, (*dep)->domain);
9092+ return 1;
9093+ }
9094
9095- int num;
9096- PipMatrix **qp = quast_to_polyhedra(lexmax, &num, (*dep)->source->depth,
9097- (*dep)->target->depth + npar);
9098-
9099- /* Update the dependence domains */
9100- if (num > 0)
9101- {
9102- int it_mat;
9103- PipMatrix* original_domain = (*dep)->domain;
9104- for (it_mat = 0; it_mat < num; ++it_mat)
9105- {
9106- new_domain = pip_matrix_alloc(original_domain->NbRows +
9107- qp[it_mat]->NbRows,
9108- original_domain->NbColumns);
9109- for (i = 0; i < original_domain->NbRows; i++)
9110- for (j = 0; j < original_domain->NbColumns; j++)
9111- CANDL_assign(new_domain->p[i][j], original_domain->p[i][j]);
9112-
9113- for (i = 0; i < qp[it_mat]->NbRows; i++)
9114- for (j = 0; j < original_domain->NbColumns; j++)
9115- CANDL_assign(new_domain->p[i+original_domain->NbRows][j],
9116- qp[it_mat]->p[i][j]);
9117-
9118- (*dep)->domain = new_domain;
9119- /* More than 1 pipmatrix from the quast, we need to insert
9120- new dependences to have the union of domains. */
9121- if (it_mat < num - 1)
9122- {
9123- CandlDependence* newdep = candl_dependence_malloc ();
9124- newdep->source = (*dep)->source;
9125- newdep->target = (*dep)->target;
9126- newdep->depth = (*dep)->depth;
9127- newdep->type = (*dep)->type;
9128- newdep->ref_source = (*dep)->ref_source;
9129- newdep->ref_target = (*dep)->ref_target;
9130- newdep->usr = (*dep)->usr;
9131- newdep->next = (*dep)->next;
9132- (*dep)->next = newdep;
9133- *dep = newdep;
9134- }
9135- }
9136-
9137- pip_matrix_free(original_domain);
9138- for (i = 0; i < num; ++i)
9139- pip_matrix_free(qp[i]);
9140+ osl_relation_p qp = pip_quast_to_polyhedra(lexmax, s_usr->depth,
9141+ t_usr->depth + npar);
9142+
9143+ /* Update the dependence domains */
9144+ if (osl_relation_nb_components(qp) > 0) {
9145+ osl_relation_p iter;
9146+ osl_relation_p original_domain = (*dep)->domain;
9147+ for (iter = qp ; iter != NULL ; iter = iter->next) {
9148+
9149+ new_domain = osl_relation_pmalloc(precision,
9150+ original_domain->nb_rows +
9151+ qp->nb_rows,
9152+ original_domain->nb_columns);
9153+
9154+ for (i = 0; i < original_domain->nb_rows; i++)
9155+ for (j = 0; j < original_domain->nb_columns; j++)
9156+ osl_int_assign(precision,
9157+ &new_domain->m[i][j],
9158+ original_domain->m[i][j]);
9159+
9160+ for (i = 0; i < qp->nb_rows; i++)
9161+ for (j = 0; j < original_domain->nb_columns; j++)
9162+ osl_int_assign(precision,
9163+ &new_domain->m[i+original_domain->nb_rows][j],
9164+ qp->m[i][j]);
9165+
9166+ (*dep)->domain = new_domain;
9167+ /* More than 1 pipmatrix from the quast, we need to insert
9168+ new dependences to have the union of domains. */
9169+ if (qp->next != NULL) {
9170+ osl_dependence_p newdep = osl_dependence_malloc();
9171+ newdep->stmt_source_ptr = (*dep)->stmt_source_ptr;
9172+ newdep->stmt_target_ptr = (*dep)->stmt_target_ptr;
9173+ newdep->depth = (*dep)->depth;
9174+ newdep->type = (*dep)->type;
9175+ newdep->label_source = (*dep)->label_source;
9176+ newdep->label_target = (*dep)->label_target;
9177+ newdep->ref_source = (*dep)->ref_source;
9178+ newdep->ref_target = (*dep)->ref_target;
9179+ newdep->usr = (*dep)->usr;
9180+ newdep->source_nb_output_dims_domain = (*dep)->source_nb_output_dims_domain;
9181+ newdep->source_nb_output_dims_access = (*dep)->source_nb_output_dims_access;
9182+ newdep->target_nb_output_dims_domain = (*dep)->target_nb_output_dims_domain;
9183+ newdep->target_nb_output_dims_access = (*dep)->target_nb_output_dims_access;
9184+ newdep->source_nb_local_dims_domain = (*dep)->source_nb_local_dims_domain;
9185+ newdep->source_nb_local_dims_access = (*dep)->source_nb_local_dims_access;
9186+ newdep->target_nb_local_dims_domain = (*dep)->target_nb_local_dims_domain;
9187+ newdep->target_nb_local_dims_access = (*dep)->target_nb_local_dims_access;
9188+ newdep->next = (*dep)->next;
9189+ (*dep)->next = newdep;
9190+ *dep = newdep;
9191 }
9192+ }
9193
9194- if (qp)
9195- free(qp);
9196- pip_quast_free(lexmax);
9197- pip_matrix_free(context);
9198+ osl_relation_free(original_domain);
9199+ osl_relation_free(qp);
9200+ }
9201
9202- return 0;
9203+ pip_quast_free(lexmax);
9204+ osl_relation_free(qp);
9205+ osl_relation_free(context);
9206+
9207+ return 0;
9208 }
9209
9210 /**
9211@@ -2751,16 +2316,15 @@ int candl_dep_compute_lastwriter (CandlDependence **dep, CandlProgram *prog)
9212 * modify the dependence polyhedra. Be careful of any references to the old
9213 * dependence polyhedra. They are freed and new ones allocated.
9214 */
9215-void candl_compute_last_writer (CandlDependence *dep, CandlProgram *prog)
9216-{
9217+void candl_compute_last_writer(osl_dependence_p dep, osl_scop_p scop) {
9218 // int count=0;
9219- while (dep != NULL) {
9220- if (dep->type != CANDL_WAR) {
9221- // printf("Last writer for dep %d: %d %d\n", count++, dep->source->depth, dep->target->depth);
9222- // candl_matrix_print(stdout, dep->domain);
9223- candl_dep_compute_lastwriter(&dep, prog);
9224- // candl_matrix_print(stdout, dep->domain);
9225- }
9226- dep = dep->next;
9227+ while (dep != NULL) {
9228+ if (dep->type != OSL_DEPENDENCE_WAR) {
9229+ // printf("Last writer for dep %d: %d %d\n", count++, dep->source->usr->depth, dep->target->usr->depth);
9230+ // candl_matrix_print(stdout, dep->domain);
9231+ candl_dep_compute_lastwriter(&dep, scop);
9232+ // candl_matrix_print(stdout, dep->domain);
9233 }
9234+ dep = dep->next;
9235+ }
9236 }
9237diff --git a/source/isl-wrapper.c b/source/isl-wrapper.c
9238index 870c9c9..36d9b05 100644
9239--- a/source/isl-wrapper.c
9240+++ b/source/isl-wrapper.c
9241@@ -6,8 +6,8 @@
9242 **---- \#/ --------------------------------------------------------**
9243 ** .-"#'-. First version: January 31st 2011 **
9244 **--- |"-.-"| -------------------------------------------------------**
9245- | |
9246- | |
9247+ | |
9248+ | |
9249 ******** | | *************************************************************
9250 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
9251 ******************************************************************************
9252@@ -41,19 +41,18 @@
9253 #include <stdlib.h>
9254 #include <stdio.h>
9255 #include <string.h>
9256-#include <candl/candl.h>
9257+#include <osl/relation.h>
9258
9259-# ifdef CANDL_SUPPORTS_ISL
9260-
9261-# undef Q
9262-# include <isl/constraint.h>
9263-# include <isl/map.h>
9264-# include <isl/map.h>
9265-# include <isl/set.h>
9266-# include <isl/dim.h>
9267-# include <isl/seq.h>
9268-# include <isl/ctx.h>
9269+#ifdef CANDL_SUPPORTS_ISL
9270
9271+#undef Q
9272+#include <isl/constraint.h>
9273+#include <isl/map.h>
9274+#include <isl/map.h>
9275+#include <isl/set.h>
9276+#include <isl/dim.h>
9277+#include <isl/seq.h>
9278+#include <isl/ctx.h>
9279
9280
9281 /// WARNING: This is hard-coding that ISL uses GMP.
9282@@ -66,8 +65,7 @@
9283 */
9284 static
9285 struct isl_constraint*
9286-isl_constraint_read_from_matrix(struct isl_dim* dim, Entier* row)
9287-{
9288+isl_constraint_read_from_matrix(struct isl_dim* dim, Entier* row) {
9289 struct isl_constraint* constraint;
9290 int j;
9291 int nvariables = isl_dim_size(dim, isl_dim_set);
9292@@ -79,17 +77,15 @@ isl_constraint_read_from_matrix(struct isl_dim* dim, Entier* row)
9293 else
9294 constraint = isl_inequality_alloc(dim);
9295
9296- for (j = 0; j < nvariables; ++j)
9297- {
9298- mpz_set_si(val, CANDL_get_si(row[1 + j]));
9299- isl_constraint_set_coefficient(constraint, isl_dim_out, j, val);
9300- }
9301+ for (j = 0; j < nvariables; ++j) {
9302+ mpz_set_si(val, CANDL_get_si(row[1 + j]));
9303+ isl_constraint_set_coefficient(constraint, isl_dim_out, j, val);
9304+ }
9305
9306- for (j = 0; j < nparam; ++j)
9307- {
9308- mpz_set_si(val, CANDL_get_si(row[1 + nvariables + j]));
9309- isl_constraint_set_coefficient(constraint, isl_dim_param, j, val);
9310- }
9311+ for (j = 0; j < nparam; ++j) {
9312+ mpz_set_si(val, CANDL_get_si(row[1 + nvariables + j]));
9313+ isl_constraint_set_coefficient(constraint, isl_dim_param, j, val);
9314+ }
9315
9316 mpz_set_si(val, CANDL_get_si(row[1 + nvariables + nparam]));
9317 isl_constraint_set_constant(constraint, val);
9318@@ -102,16 +98,16 @@ isl_constraint_read_from_matrix(struct isl_dim* dim, Entier* row)
9319
9320 struct isl_set*
9321 isl_set_from_piplib_matrix(struct isl_ctx* ctx,
9322- PipMatrix* matrix,
9323- int nparam)
9324-{
9325+ osl_relation_p matrix,
9326+ int nparam) {
9327+ PipMatrix* pmatrix = pip_relation2matrix(matrix);
9328 struct isl_dim* dim;
9329 struct isl_basic_set* bset;
9330 int i;
9331 unsigned nrows, ncolumns;
9332
9333- nrows = matrix->NbRows;
9334- ncolumns = matrix->NbColumns;
9335+ nrows = pmatrix->NbRows;
9336+ ncolumns = pmatrix->NbColumns;
9337 int nvariables = ncolumns - 2 - nparam;
9338
9339 dim = isl_dim_set_alloc(ctx, nparam, nvariables);
9340@@ -119,36 +115,33 @@ isl_set_from_piplib_matrix(struct isl_ctx* ctx,
9341 bset = isl_basic_set_universe(isl_dim_copy(dim));
9342
9343 for (i = 0; i < nrows; ++i) {
9344- Entier* row = matrix->p[i];
9345+ Entier* row = pmatrix->p[i];
9346 struct isl_constraint* constraint =
9347- isl_constraint_read_from_matrix(isl_dim_copy(dim), row);
9348+ isl_constraint_read_from_matrix(isl_dim_copy(dim), row);
9349 bset = isl_basic_set_add_constraint(bset, constraint);
9350 }
9351
9352 isl_dim_free(dim);
9353
9354- return isl_set_from_basic_set(bset);;
9355+ return isl_set_from_basic_set(bset);
9356 }
9357
9358
9359 static
9360-int count_cst(__isl_take isl_constraint *c, void *user)
9361-{
9362+int count_cst(__isl_take isl_constraint *c, void *user) {
9363 (*((int*)user))++;
9364
9365 return 0;
9366 }
9367
9368
9369-
9370 static
9371-int copy_cst_to_mat(__isl_take isl_constraint *c, void *user)
9372-{
9373+int copy_cst_to_mat(__isl_take isl_constraint *c, void *user) {
9374 // 1- Get the first free row of the matrix.
9375 int pos;
9376 PipMatrix* mat = (PipMatrix*)user;
9377 for (pos = 0; pos < mat->NbRows &&
9378- CANDL_get_si(mat->p[pos][0]) != -1; ++pos)
9379+ CANDL_get_si(mat->p[pos][0]) != -1; ++pos)
9380 ;
9381
9382 // 2- Set the eq/ineq bit.
9383@@ -161,17 +154,15 @@ int copy_cst_to_mat(__isl_take isl_constraint *c, void *user)
9384 isl_int val; isl_int_init(val);
9385 int j;
9386 int nb_vars = isl_constraint_dim(c, isl_dim_set);
9387- for (j = 0; j < nb_vars; ++j)
9388- {
9389- isl_constraint_get_coefficient(c, isl_dim_set, j, &val);
9390- CANDL_set_si(mat->p[pos][j + 1], isl_int_get_si(val));
9391- }
9392+ for (j = 0; j < nb_vars; ++j) {
9393+ isl_constraint_get_coefficient(c, isl_dim_set, j, &val);
9394+ CANDL_set_si(mat->p[pos][j + 1], isl_int_get_si(val));
9395+ }
9396 int nb_param = isl_constraint_dim(c, isl_dim_param);
9397- for (j = 0; j < nb_param; ++j)
9398- {
9399- isl_constraint_get_coefficient(c, isl_dim_param, j, &val);
9400- CANDL_set_si(mat->p[pos][j + nb_vars + 1], isl_int_get_si(val));
9401- }
9402+ for (j = 0; j < nb_param; ++j) {
9403+ isl_constraint_get_coefficient(c, isl_dim_param, j, &val);
9404+ CANDL_set_si(mat->p[pos][j + nb_vars + 1], isl_int_get_si(val));
9405+ }
9406 isl_constraint_get_constant(c, &val);
9407 CANDL_set_si(mat->p[pos][mat->NbColumns - 1], isl_int_get_si(val));
9408
9409@@ -181,19 +172,17 @@ int copy_cst_to_mat(__isl_take isl_constraint *c, void *user)
9410 }
9411
9412
9413-int bset_get(__isl_take isl_basic_set *bset, void *user)
9414-{
9415+int bset_get(__isl_take isl_basic_set *bset, void *user) {
9416 *((struct isl_basic_set**)user) = bset;
9417
9418 return 0;
9419 }
9420
9421
9422-PipMatrix*
9423+osl_relation_p
9424 isl_set_to_piplib_matrix(struct isl_ctx* ctx,
9425- struct isl_set* set,
9426- int nparam)
9427-{
9428+ struct isl_set* set,
9429+ int nparam) {
9430 struct isl_basic_set* bset = NULL;
9431 // There is only one basic set in this set.
9432 isl_set_foreach_basic_set(set, bset_get, &bset);
9433@@ -215,8 +204,11 @@ isl_set_to_piplib_matrix(struct isl_ctx* ctx,
9434
9435 // 4- Convert each constraint to a row of the matrix.
9436 isl_basic_set_foreach_constraint(bset, copy_cst_to_mat, res);
9437-
9438- return res;
9439+
9440+ osl_relation_p tmp = pip_matrix2relation(res);
9441+ pip_matrix_free(res);
9442+
9443+ return tmp;
9444 }
9445
9446
9447diff --git a/source/matrix.c b/source/matrix.c
9448index 03c8546..8c3a1aa 100644
9449--- a/source/matrix.c
9450+++ b/source/matrix.c
9451@@ -6,8 +6,8 @@
9452 **---- \#/ --------------------------------------------------------**
9453 ** .-"#'-. First version: december 9th 2005 **
9454 **--- |"-.-"| -------------------------------------------------------**
9455- | |
9456- | |
9457+ | |
9458+ | |
9459 ******** | | *************************************************************
9460 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
9461 ******************************************************************************
9462@@ -36,298 +36,18 @@
9463 * please feel free to correct and improve it !
9464 */
9465
9466-# include <stdlib.h>
9467-# include <stdio.h>
9468-# include <ctype.h>
9469-# include <string.h>
9470-# include <candl/candl.h>
9471-
9472-/******************************************************************************
9473- * Structure display function *
9474- ******************************************************************************/
9475-
9476-
9477-/**
9478- * candl_matrix_print_structure function:
9479- * Displays a CandlMatrix structure (matrix) into a file (file, possibly stdout)
9480- * in a way that trends to be understandable without falling in a deep
9481- * depression or, for the lucky ones, getting a headache... It includes an
9482- * indentation level (level) in order to work with others print_structure
9483- * functions.
9484- * - 09/12/2005: first version (from CLooG 0.14.0).
9485- */
9486-void candl_matrix_print_structure(FILE * file, CandlMatrix * matrix, int level)
9487-{ int i, j ;
9488-
9489- if (matrix != NULL)
9490- { /* Go to the right level. */
9491- for(j=0; j<level; j++)
9492- fprintf(file,"|\t") ;
9493- fprintf(file,"+-- CandlMatrix\n") ;
9494-
9495- for(j=0; j<=level; j++)
9496- fprintf(file,"|\t") ;
9497- fprintf(file,"%d %d\n",matrix->NbRows,matrix->NbColumns) ;
9498-
9499- /* Display the matrix. */
9500- for (i=0; i<matrix->NbRows; i++)
9501- { for(j=0; j<=level; j++)
9502- fprintf(file,"|\t") ;
9503-
9504- fprintf(file,"[ ") ;
9505-
9506- for (j=0; j<matrix->NbColumns; j++)
9507- { CANDL_print(file,CANDL_FMT,matrix->p[i][j]) ;
9508- fprintf(file," ") ;
9509- }
9510-
9511- fprintf(file,"]\n") ;
9512- }
9513- }
9514- else
9515- { /* Go to the right level. */
9516- for(j=0; j<level; j++)
9517- fprintf(file,"|\t") ;
9518- fprintf(file,"+-- NULL matrix\n") ;
9519- }
9520-
9521- /* The last line. */
9522- for(j=0; j<=level; j++)
9523- fprintf(file,"|\t") ;
9524- fprintf(file,"\n") ;
9525-}
9526-
9527-
9528-/**
9529- * candl_matrix_print function:
9530- * This function prints the content of a CandlMatrix structure (matrix) into a
9531- * file (file, possibly stdout).
9532- * - 09/12/2005: first version (from CLooG 0.14.0).
9533- */
9534-void candl_matrix_print(FILE * file, CandlMatrix * matrix)
9535-{ candl_matrix_print_structure(file,matrix,0) ;
9536-}
9537-
9538-
9539-
9540-/**
9541- * candl_matrix_print_data function:
9542- * This function prints the content of a CandlMatrix data (matrix) into a
9543- * file (file, possibly stdout).
9544- */
9545-void candl_matrix_print_data(FILE * file, CandlMatrix * matrix)
9546-{
9547- int i, j;
9548-
9549- fprintf (file, "%d %d\n", matrix->NbRows, matrix->NbColumns);
9550- for (i = 0; i < matrix->NbRows; ++i)
9551- {
9552- for (j = 0; j < matrix->NbColumns; ++j)
9553- CANDL_print(file,CANDL_FMT,matrix->p[i][j]);
9554- fprintf (file, "\n");
9555- }
9556-}
9557-
9558-
9559-/**
9560- * candl_matrix_list_print_structure function:
9561- * Displays a CandlMatrixList structure (list) into a file (file, possibly
9562- * stdout) in a way that trends to be understandable without falling in a deep
9563- * depression or, for the lucky ones, getting a headache... It includes an
9564- * indentation level (level) in order to work with others print_structure
9565- * functions.
9566- * - 11/12/2005: first version.
9567- */
9568-void candl_matrix_list_print_structure(file, list, level)
9569-FILE * file ;
9570-CandlMatrixList *list ;
9571-int level ;
9572-{ int i, j, first=1 ;
9573-
9574- if (list != NULL)
9575- { /* Go to the right level. */
9576- for(j=0; j<level; j++)
9577- fprintf(file,"|\t") ;
9578- fprintf(file,"+-- CandlMatrixList\n") ;
9579- }
9580- else
9581- { /* Go to the right level. */
9582- for(j=0; j<level; j++)
9583- fprintf(file,"|\t") ;
9584- fprintf(file,"+-- NULL matrix list\n") ;
9585- }
9586-
9587- while (list != NULL)
9588- { if (!first)
9589- { /* Go to the right level. */
9590- for(j=0; j<level; j++)
9591- fprintf(file,"|\t") ;
9592- fprintf(file,"| CandlMatrixList\n") ;
9593- }
9594- else
9595- first = 0 ;
9596-
9597- /* A blank line. */
9598- for(j=0; j<=level+1; j++)
9599- fprintf(file,"|\t") ;
9600- fprintf(file,"\n") ;
9601-
9602- /* Print the matrix. */
9603- candl_matrix_print_structure(file,list->matrix,level+1) ;
9604-
9605- /* Next line. */
9606- if (list->next != NULL)
9607- { for(i=0; i<=level; i++)
9608- fprintf(file,"|\t") ;
9609- fprintf(file,"V\n") ;
9610- }
9611- list = list->next ;
9612- }
9613-
9614- /* The last line. */
9615- for(j=0; j<=level; j++)
9616- fprintf(file,"|\t") ;
9617- fprintf(file,"\n") ;
9618-}
9619-
9620-
9621-/**
9622- * candl_matrix_list_print function:
9623- * This function prints the content of a CandlMatrixList structure (list) into a
9624- * file (file, possibly stdout).
9625- * - 11/12/2005: first version.
9626- */
9627-void candl_matrix_list_print(FILE * file, CandlMatrixList * list)
9628-{ candl_matrix_list_print_structure(file,list,0) ;
9629-}
9630-
9631-
9632-/******************************************************************************
9633- * Memory deallocation function *
9634- ******************************************************************************/
9635-
9636-
9637-/**
9638- * candl_matrix_free function:
9639- * This function frees the allocated memory for a CandlMatrix structure.
9640- * - 09/12/2005: first version.
9641- */
9642-void candl_matrix_free(CandlMatrix * matrix)
9643-{ pip_matrix_free(matrix) ;
9644-}
9645-
9646-
9647-/**
9648- * candl_matrix_list_free function:
9649- * This function frees the allocated memory for a CandlMatrixList structure.
9650- * - 11/12/2005: first version.
9651- */
9652-void candl_matrix_list_free(CandlMatrixList * list)
9653-{ CandlMatrixList * next ;
9654-
9655- while (list != NULL)
9656- { next = list->next ;
9657- pip_matrix_free(list->matrix) ;
9658- free(list) ;
9659- list = next ;
9660- }
9661-}
9662-
9663-
9664-/******************************************************************************
9665- * Reading functions *
9666- ******************************************************************************/
9667-
9668-
9669-/**
9670- * candl_matrix_read function:
9671- * This function reads a matrix into a file (foo, posibly stdin) and returns a
9672- * pointer to a CandlMatrix containing the read informations.
9673- * - 09/12/2005: first version.
9674- */
9675-CandlMatrix * candl_matrix_read(FILE * file)
9676-{ return pip_matrix_read(file) ;
9677-}
9678-
9679-
9680-/**
9681- * cloog_domain_list_read function:
9682- * This function reads a list of matrices into a file (foo, posibly stdin) and
9683- * returns a pointer to a CandlMatrixList containing the read information.
9684- * - 11/12/2005: first version (from CLooG 0.14.0's cloog_domain_list_read).
9685- */
9686-CandlMatrixList * candl_matrix_list_read(FILE * file)
9687-{ int i, nb_matrices ;
9688- char s[CANDL_MAX_STRING] ;
9689- CandlMatrixList * list, * now, * next ;
9690-
9691- /* We read first the number of matrices in the list. */
9692- while (fgets(s,CANDL_MAX_STRING,file) == 0) ;
9693- while ((*s=='#' || *s=='\n') || (sscanf(s," %d",&nb_matrices)<1))
9694- fgets(s,CANDL_MAX_STRING,file) ;
9695-
9696- /* Then we read the matrices. */
9697- list = NULL ;
9698- if (nb_matrices > 0)
9699- { list = (CandlMatrixList *)malloc(sizeof(CandlMatrixList)) ;
9700- list->matrix = candl_matrix_read(file) ;
9701- list->next = NULL ;
9702- now = list ;
9703- for (i=1;i<nb_matrices;i++)
9704- { next = (CandlMatrixList *)malloc(sizeof(CandlMatrixList)) ;
9705- next->matrix = candl_matrix_read(file) ;
9706- next->next = NULL ;
9707- now->next = next ;
9708- now = now->next ;
9709- }
9710- }
9711-
9712- return(list) ;
9713-}
9714-
9715-
9716-/******************************************************************************
9717- * Processing functions *
9718- ******************************************************************************/
9719-
9720-
9721-/**
9722- * candl_matrix_malloc function:
9723- * This function allocates the memory space for a CandlMatrix structure and
9724- * sets its fields with default values. Then it returns a pointer to the
9725- * allocated space.
9726- * - 09/12/2005: first version.
9727- */
9728-CandlMatrix * candl_matrix_malloc(int nb_rows, int nb_columns)
9729-{ return pip_matrix_alloc(nb_rows,nb_columns) ;
9730-}
9731-
9732-
9733-/**
9734- * candl_matrix_list_malloc function:
9735- * This function allocates the memory space for a CandlMatrixList structure and
9736- * sets its fields with default values. Then it returns a pointer to the
9737- * allocated space.
9738- * - 11/12/2005: first version.
9739- */
9740-CandlMatrixList * candl_matrix_list_malloc()
9741-{ CandlMatrixList * list ;
9742-
9743- /* Memory allocation for the CandlDependence structure. */
9744- list = (CandlMatrixList *)malloc(sizeof(CandlMatrixList)) ;
9745- if (list == NULL)
9746- { fprintf(stderr, "[Candl]ERROR: memory overflow.\n") ;
9747- exit(1) ;
9748- }
9749-
9750- /* We set the various fields with default values. */
9751- list->matrix = NULL ;
9752- list->next = NULL ;
9753-
9754- return list ;
9755-}
9756-
9757-
9758+#include <stdlib.h>
9759+#include <stdio.h>
9760+#include <ctype.h>
9761+#include <string.h>
9762+#include <osl/macros.h>
9763+#include <osl/relation.h>
9764+#include <osl/extensions/dependence.h>
9765+#include <candl/macros.h>
9766+#include <candl/matrix.h>
9767+#include <candl/violation.h>
9768+#include <candl/piplib.h>
9769+#include <candl/piplib-wrapper.h>
9770
9771
9772 /**
9773@@ -335,7 +55,7 @@ CandlMatrixList * candl_matrix_list_malloc()
9774 * this function builds the constraint system corresponding to a violation of a
9775 * dependence, for a given transformation couple at a given depth.
9776 * - dependence is the constraint system of a dependence between two
9777- statements,
9778+ statements,
9779 * - t_source is the transformation function for the source statement,
9780 * - t_target is the transformation function for the target statement,
9781 * - dimension is the transformation dimension checked for legality,
9782@@ -343,116 +63,249 @@ CandlMatrixList * candl_matrix_list_malloc()
9783 ***
9784 * - 13/12/2005: first version (extracted from candl_violation).
9785 */
9786-CandlMatrix * candl_matrix_violation(dependence,t_source,t_target,
9787- dimension,nb_par)
9788-CandlMatrix * dependence, * t_source, * t_target ;
9789-int dimension, nb_par ;
9790-{ int i, j, nb_rows, nb_columns, constraint, s_dims, t_dims ;
9791- CandlMatrix * system ;
9792- Entier temp ;
9793-
9794- CANDL_init(temp) ;
9795-
9796- /* The number of dimensions of the source and target domains. */
9797- s_dims = t_source->NbColumns - nb_par - 2 ;
9798- t_dims = t_target->NbColumns - nb_par - 2 ;
9799-
9800- /* Size of the constraint system. */
9801- nb_rows = dependence->NbRows + dimension + 1 ;
9802- nb_columns = dependence->NbColumns ;
9803-
9804- /* We allocate memory space for the constraint system. */
9805- system = candl_matrix_malloc(nb_rows, nb_columns) ;
9806-
9807- /* We fill the constraint system (there is no need to put zeros in the
9808- * empty zones since candl_matrix_alloc initialized all to 0):
9809- */
9810-
9811- /* 1. We copy the constraints of the dependence polyhedron. */
9812- for (i = 0; i < dependence->NbRows; i++)
9813- for (j = 0; j < dependence->NbColumns; j++)
9814- CANDL_assign(system->p[i][j],dependence->p[i][j]) ;
9815-
9816- constraint = dependence->NbRows ;
9817-
9818- /* 2. We set the equality constraints (equality tag is already 0). */
9819- for (i = 0; i < dimension; i++)
9820- { /* The source dimension part. */
9821- for (j = 1; j <= s_dims; j++)
9822- CANDL_assign(system->p[constraint][j],t_source->p[i][j]) ;
9823+candl_violation_p candl_matrix_violation(osl_dependence_p dependence,
9824+ osl_relation_p source,
9825+ osl_relation_p target,
9826+ int dimension, int nb_par) {
9827+ candl_violation_p violation;
9828+ osl_relation_p system;
9829+ int i, j, k, c;
9830+ int constraint = 0;
9831+ int precision = dependence->domain->precision;
9832+ int nb_rows, nb_columns;
9833+ int nb_output_dims, nb_input_dims, nb_local_dims;
9834+ int ind_source_output_scatt;
9835+ int ind_target_output_scatt;
9836+ int ind_source_local_scatt;
9837+ int ind_target_local_scatt;
9838+ int ind_params;
9839+
9840+ /* Create a new violation structure */
9841+ violation = candl_violation_malloc();
9842+
9843+ violation->source_nb_output_dims_scattering = source->nb_output_dims;
9844+ violation->target_nb_output_dims_scattering = target->nb_output_dims;
9845+ violation->source_nb_local_dims_scattering = source->nb_local_dims;
9846+ violation->target_nb_local_dims_scattering = target->nb_local_dims;
9847+
9848+ /* Compute the system size */
9849+ nb_local_dims = dependence->domain->nb_local_dims +
9850+ violation->source_nb_local_dims_scattering +
9851+ violation->target_nb_local_dims_scattering;
9852+ nb_output_dims = dependence->domain->nb_output_dims +
9853+ violation->source_nb_output_dims_scattering;
9854+ nb_input_dims = dependence->domain->nb_input_dims +
9855+ violation->target_nb_output_dims_scattering;
9856+
9857+ nb_columns = nb_output_dims + nb_input_dims + nb_local_dims + nb_par + 2;
9858+ nb_rows = dependence->domain->nb_rows +
9859+ source->nb_rows + target->nb_rows +
9860+ dimension;
9861+
9862+ system = osl_relation_pmalloc(precision, nb_rows, nb_columns);
9863+
9864+ /* Compute some indexes */
9865+ ind_source_output_scatt = 1 + dependence->domain->nb_output_dims;
9866+ ind_target_output_scatt = ind_source_output_scatt + source->nb_output_dims +
9867+ dependence->domain->nb_input_dims;
9868+ ind_source_local_scatt = ind_target_output_scatt + target->nb_output_dims +
9869+ dependence->domain->nb_local_dims;
9870+ ind_target_local_scatt = ind_source_local_scatt + source->nb_local_dims +
9871+ dependence->domain->nb_local_dims;
9872+ ind_params = ind_target_local_scatt + target->nb_local_dims;
9873+
9874+ /* 1. Copy the dependence domain */
9875+ for (i = 0 ; i < dependence->domain->nb_rows ; i++) {
9876+ /* eq/in */
9877+ osl_int_assign(precision,
9878+ &system->m[constraint][0],
9879+ dependence->domain->m[i][0]);
9880+ /* output dims */
9881+ k = 1;
9882+ j = 1;
9883+ for (c = dependence->domain->nb_output_dims ; c > 0 ; c--, k++, j++)
9884+ osl_int_assign(precision,
9885+ &system->m[constraint][k],
9886+ dependence->domain->m[i][j]);
9887+ /* input dims */
9888+ k += source->nb_output_dims;
9889+ for (c = dependence->domain->nb_input_dims ; c > 0 ; c--, k++, j++)
9890+ osl_int_assign(precision,
9891+ &system->m[constraint][k],
9892+ dependence->domain->m[i][j]);
9893+ /* source local dims */
9894+ k += target->nb_output_dims;
9895+ for (c = dependence->source_nb_local_dims_domain +
9896+ dependence->source_nb_local_dims_access ; c > 0 ; c--, k++, j++)
9897+ osl_int_assign(precision,
9898+ &system->m[constraint][k],
9899+ dependence->domain->m[i][j]);
9900+ /* target local dims */
9901+ k += source->nb_local_dims;
9902+ for (c = dependence->target_nb_local_dims_domain +
9903+ dependence->target_nb_local_dims_access ; c > 0 ; c--, k++, j++)
9904+ osl_int_assign(precision,
9905+ &system->m[constraint][k],
9906+ dependence->domain->m[i][j]);
9907+ /* params + const */
9908+ k = ind_params;
9909+ for (c = nb_par+1 ; c > 0 ; c--, k++, j++)
9910+ osl_int_assign(precision,
9911+ &system->m[constraint][k],
9912+ dependence->domain->m[i][j]);
9913+ constraint++;
9914+ }
9915+
9916+ /* 2. Copy the source scattering */
9917+ for (i = 0 ; i < source->nb_rows ; i++) {
9918+ /* eq/in */
9919+ osl_int_assign(precision,
9920+ &system->m[constraint][0],
9921+ source->m[i][0]);
9922+ /* output dims */
9923+ k = ind_source_output_scatt;
9924+ j = 1;
9925+ for (c = source->nb_output_dims ; c > 0 ; c--, k++, j++)
9926+ osl_int_assign(precision,
9927+ &system->m[constraint][k],
9928+ source->m[i][j]);
9929+ /* input dims (linked with the output dims of domain) */
9930+ k = 1;
9931+ for (c = source->nb_input_dims ; c > 0 ; c--, k++, j++)
9932+ osl_int_assign(precision,
9933+ &system->m[constraint][k],
9934+ source->m[i][j]);
9935+ /* local dims */
9936+ k = ind_source_local_scatt;
9937+ for (c = source->nb_local_dims ; c > 0 ; c--, k++, j++)
9938+ osl_int_assign(precision,
9939+ &system->m[constraint][k],
9940+ source->m[i][j]);
9941+ /* params + const */
9942+ k = ind_params;
9943+ for (c = nb_par+1 ; c > 0 ; c--, k++, j++)
9944+ osl_int_assign(precision,
9945+ &system->m[constraint][k],
9946+ source->m[i][j]);
9947+ constraint++;
9948+ }
9949
9950- /* The -target dimension part. */
9951- for (; j <= s_dims + t_dims; j++)
9952- { CANDL_oppose(temp,t_target->p[i][j - s_dims]) ;
9953- CANDL_assign(system->p[constraint][j], temp) ;
9954+ /* 2. Copy the target scattering */
9955+ for (i = 0 ; i < target->nb_rows ; i++) {
9956+ /* eq/in */
9957+ osl_int_assign(precision,
9958+ &system->m[constraint][0],
9959+ target->m[i][0]);
9960+ /* output dims */
9961+ k = ind_target_output_scatt;
9962+ j = 1;
9963+ for (c = target->nb_output_dims ; c > 0 ; c--, k++, j++) {
9964+ osl_int_assign(precision,
9965+ &system->m[constraint][k],
9966+ target->m[i][j]);
9967+ osl_int_oppose(precision,
9968+ &system->m[constraint][k],
9969+ system->m[constraint][k]);
9970 }
9971-
9972- /* The source-target parameter/scalar part. */
9973- for (; j < nb_columns; j++)
9974- CANDL_subtract(system->p[constraint][j],
9975- t_source->p[i][j - t_dims],
9976- t_target->p[i][j - s_dims]) ;
9977- constraint++ ;
9978+ /* input dims (linked with the output dims of domain) */
9979+ k = 1 + nb_output_dims;
9980+ for (c = target->nb_input_dims ; c > 0 ; c--, k++, j++) {
9981+ osl_int_assign(precision,
9982+ &system->m[constraint][k],
9983+ target->m[i][j]);
9984+ osl_int_oppose(precision,
9985+ &system->m[constraint][k],
9986+ system->m[constraint][k]);
9987+ }
9988+ /* local dims */
9989+ k = ind_target_local_scatt;
9990+ for (c = target->nb_local_dims ; c > 0 ; c--, k++, j++) {
9991+ osl_int_assign(precision,
9992+ &system->m[constraint][k],
9993+ target->m[i][j]);
9994+ osl_int_oppose(precision,
9995+ &system->m[constraint][k],
9996+ system->m[constraint][k]);
9997+ }
9998+ /* params + const */
9999+ k = ind_params;
10000+ for (c = nb_par+1 ; c > 0 ; c--, k++, j++) {
10001+ osl_int_assign(precision,
10002+ &system->m[constraint][k],
10003+ target->m[i][j]);
10004+ osl_int_oppose(precision,
10005+ &system->m[constraint][k],
10006+ system->m[constraint][k]);
10007+ }
10008+ constraint++;
10009 }
10010-
10011- /* 3. We set the target < source constraint. */
10012- /* This is an inequality. */
10013- CANDL_set_si(system->p[constraint][0], 1) ;
10014-
10015- /* The source dimension part. */
10016- for (j = 1; j<= s_dims; j++)
10017- CANDL_assign(system->p[constraint][j],t_source->p[dimension][j]) ;
10018-
10019- /* The -target dimension part. */
10020- for (; j<= s_dims + t_dims; j++)
10021- { CANDL_oppose(temp,t_target->p[dimension][j - s_dims]) ;
10022- CANDL_assign(system->p[constraint][j],temp) ;
10023+
10024+ /* 3. We set the equality constraints */
10025+ k = ind_source_output_scatt;
10026+ j = ind_target_output_scatt;
10027+ for (i = 1; i < dimension; i++, k++, j++) {
10028+ /* source */
10029+ osl_int_set_si(precision, &system->m[constraint][k], 1);
10030+ /* target */
10031+ osl_int_set_si(precision, &system->m[constraint][j], -1);
10032+ constraint++;
10033 }
10034
10035- /* The source-target parameter/scalar part. */
10036- for (; j < nb_columns; j++)
10037- CANDL_subtract(system->p[constraint][j],
10038- t_source->p[dimension][j - t_dims],
10039- t_target->p[dimension][j - s_dims]) ;
10040+ /* 4. We set the target < source constraint. */
10041+ osl_int_set_si(precision, &system->m[constraint][0], 1);
10042+ /* source */
10043+ osl_int_set_si(precision, &system->m[constraint][k], 1);
10044+ /* target */
10045+ osl_int_set_si(precision, &system->m[constraint][j], -1);
10046 /* We subtract 1 to the scalar to achieve >0 constraint. */
10047- CANDL_decrement(system->p[constraint][nb_columns - 1],
10048- system->p[constraint][nb_columns - 1]) ;
10049-
10050- CANDL_clear(temp) ;
10051- return system ;
10052+ osl_int_decrement(precision,
10053+ &system->m[constraint][nb_columns - 1],
10054+ system->m[constraint][nb_columns - 1]);
10055+
10056+ system->nb_output_dims = nb_output_dims;
10057+ system->nb_input_dims = nb_input_dims;
10058+ system->nb_parameters = nb_par;
10059+ system->nb_local_dims = nb_local_dims;
10060+ system->type = OSL_UNDEFINED;
10061+
10062+ violation->domain = system;
10063+
10064+ return violation;
10065 }
10066
10067
10068-
10069-
10070 /**
10071 * candl_matrix_check_point function:
10072 * This function checks if there is an integral point in the set of
10073 * constraints, provided a given domain (possibly NULL).
10074 *
10075+ * FIXME : is it the same as pip_has_rational_point ?
10076+ * here options->Nq = 1 (default)
10077 */
10078 int
10079-candl_matrix_check_point (CandlMatrix* domain,
10080- CandlMatrix* context)
10081-{
10082-#ifdef CANDL_HAS_PIPLIB_HYBRID
10083- return piplib_hybrid_has_integer_point (domain, context, 0);
10084-#else
10085+candl_matrix_check_point(osl_relation_p domain,
10086+ osl_relation_p context) {
10087+// FIXME : compatibility with osl
10088+//#ifdef CANDL_HAS_PIPLIB_HYBRID
10089+// return piplib_hybrid_has_integer_point (domain, context, 0);
10090+//#else
10091 PipOptions* options;
10092 PipQuast* solution;
10093 int ret = 0;
10094- options = pip_options_init ();
10095+ options = pip_options_init();
10096 options->Simplify = 1;
10097 options->Urs_parms = -1;
10098 options->Urs_unknowns = -1;
10099- solution = pip_solve (domain, context, -1, options);
10100+
10101+ solution = pip_solve_osl(domain, context, -1, options);
10102
10103 if ((solution != NULL) &&
10104 ((solution->list != NULL) || (solution->condition != NULL)))
10105 ret = 1;
10106- pip_options_free (options);
10107- pip_quast_free (solution);
10108+ pip_options_free(options);
10109+ pip_quast_free(solution);
10110
10111 return ret;
10112-#endif
10113+//#endif
10114 }
10115+
10116diff --git a/source/options.c b/source/options.c
10117index fea449f..91a738a 100644
10118--- a/source/options.c
10119+++ b/source/options.c
10120@@ -6,8 +6,8 @@
10121 **---- \#/ --------------------------------------------------------**
10122 ** .-"#'-. First version: september 8th 2003 **
10123 **--- |"-.-"| -------------------------------------------------------**
10124- | |
10125- | |
10126+ | |
10127+ | |
10128 ******** | | *************************************************************
10129 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
10130 ******************************************************************************
10131@@ -37,7 +37,7 @@
10132 #include <stdlib.h>
10133 #include <stdio.h>
10134 #include <string.h>
10135-#include <candl/candl.h>
10136+#include <candl/macros.h>
10137 #include <candl/options.h>
10138
10139
10140@@ -48,12 +48,11 @@
10141
10142 /**
10143 * candl_option_print function:
10144- * This function prints the content of a CandlOptions structure (program) into
10145+ * This function prints the content of a candl_options_t structure (program) into
10146 * a file (foo, possibly stdout).
10147 * April 19th 2003: first version.
10148 */
10149-void candl_options_print(FILE * foo, CandlOptions * options)
10150-{
10151+void candl_options_print(FILE * foo, candl_options_p options) {
10152 fprintf(foo, "Options:\n");
10153 }
10154
10155@@ -65,11 +64,10 @@ void candl_options_print(FILE * foo, CandlOptions * options)
10156
10157 /**
10158 * candl_options_free function:
10159- * This function frees the allocated memory for a CandlOptions structure.
10160+ * This function frees the allocated memory for a candl_options_t structure.
10161 * April 19th 2003: first version.
10162 */
10163-void candl_options_free(CandlOptions * options)
10164-{
10165+void candl_options_free(candl_options_p options) {
10166 free(options);
10167 }
10168
10169@@ -81,19 +79,17 @@ void candl_options_free(CandlOptions * options)
10170
10171 /**
10172 * candl_options_malloc function:
10173- * This functions allocate the memory space for a CandlOptions structure and
10174+ * This functions allocate the memory space for a candl_options_t structure and
10175 * fill its fields with the defaults values. It returns a pointer to the
10176- * allocated CandlOptions structure.
10177+ * allocated candl_options_t structure.
10178 * April 19th 2003: first version.
10179 */
10180-CandlOptions * candl_options_malloc(void)
10181-{
10182- CandlOptions * options;
10183-
10184- /* Memory allocation for the CandlOptions structure. */
10185- options = (CandlOptions *) malloc(sizeof(CandlOptions));
10186- if (options == NULL)
10187- {
10188+candl_options_p candl_options_malloc(void) {
10189+ candl_options_p options;
10190+
10191+ /* Memory allocation for the candl_options_t structure. */
10192+ options = (candl_options_p) malloc(sizeof(candl_options_t));
10193+ if (options == NULL) {
10194 fprintf(stderr, "[Candl]ERROR: memory overflow.\n");
10195 exit(1);
10196 }
10197@@ -106,16 +102,13 @@ CandlOptions * candl_options_malloc(void)
10198 options->rar = 0; /* RAR (input) dependences don't matter. */
10199 options->commute = 0; /* Don't use commutativity to simplify dependences.*/
10200 options->fullcheck = 0; /* Don't compute all violations.*/
10201- options->depgraph = 0; /* Don't print the dependence graph.*/
10202- options->violgraph = 0; /* Don' compute the violation graph.*/
10203 options->scalar_renaming = 0; /* Don't enable scalar renaming. */
10204 options->scalar_privatization = 0; /* Don't enable scalar privatization. */
10205 options->scalar_expansion = 0; /* Don't enable scalar expansion. */
10206 options->lastwriter = 0; /* Compute the last writer for RAW and WAW dependences */
10207- options->readscop = 0; /* Don't read a .scop format for the input. */
10208- options->writescop = 0; /* Don't write a .scop format for the output. */
10209- options->scoptocandl = 0; /* Don't act as a .scop to candl converter. */
10210 options->verbose = 0; /* Don't be verbose. */
10211+ options->outscop = 0; /* Don't print the scop. */
10212+ options->autocorrect = 0; /* Don't correct violations. */
10213 /* UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY */
10214 options->view = 0; /* Do not visualize the graph with dot and gv.*/
10215 options->structure = 0; /* Don't print internal dependence structure. */
10216@@ -132,54 +125,54 @@ CandlOptions * candl_options_malloc(void)
10217 * limitation of the ISO C 89 compilers.
10218 * August 5th 2002: first version.
10219 */
10220-void candl_options_help()
10221-{ printf(
10222- "Usage: candl [ options | file ] ...\n"
10223- "Options for data dependence computation:\n"
10224- " -waw <boolean> Consider WAW (output) dependences (1) or not (0)\n"
10225- " (default setting: 1).\n"
10226- " -raw <boolean> Consider RAW (flow) dependences (1) or not (0)\n"
10227- " (default setting: 1).\n"
10228- " -war <boolean> Consider WAR (anti) dependences (1) or not (0)\n"
10229- " (default setting: 1).\n"
10230- " -rar <boolean> Consider RAR (input) dependences (1) or not (0)\n"
10231- " (default setting: 0).\n");
10232+void candl_options_help() {
10233+ printf(
10234+ "Usage: candl [ options | file ] ...\n"
10235+ "Options for data dependence computation:\n"
10236+ " -waw <boolean> Consider WAW (output) dependences (1) or not (0)\n"
10237+ " (default setting: 1).\n"
10238+ " -raw <boolean> Consider RAW (flow) dependences (1) or not (0)\n"
10239+ " (default setting: 1).\n"
10240+ " -war <boolean> Consider WAR (anti) dependences (1) or not (0)\n"
10241+ " (default setting: 1).\n"
10242+ " -rar <boolean> Consider RAR (input) dependences (1) or not (0)\n"
10243+ " (default setting: 0).\n");
10244 printf(
10245- " -commute <boolean> Consider commutativity (1) or not (0)\n"
10246- " (default setting: 0).\n"
10247- " -fullcheck <boolean> Compute all legality violation (1) or only one (0)\n"
10248- " (default setting: 0).\n"
10249- " -depgraph <boolean> Ask to print the dependence graph (1) or not (0)\n"
10250- " (default setting: 0 but 1 if no transformation).\n"
10251- " -violgraph <boolean> Ask to print the violation graph (1) or not (0)\n"
10252- " (default setting: 1 but 0 if no transformation).\n"
10253- " -scalren <boolean> Ask to enable scalar renaming (1) or not (0)\n"
10254- " (default setting: 0).\n"
10255- " -scalpriv <boolean> Ask to enable scalar privatization (1) or not (0)\n"
10256- " (default setting: 0).\n"
10257- " -scalexp <boolean> Ask to enable scalar expansion (1) or not (0)\n"
10258- " (default setting: 0).\n");
10259+ " -commute <boolean> Consider commutativity (1) or not (0)\n"
10260+ " (default setting: 0).\n"
10261+ " -fullcheck <boolean> Compute all legality violation (1) or just the\n"
10262+ " first (0)\n"
10263+ " (default setting: 0, or 1 if autocorrect is set).\n"
10264+ " -scalren <boolean> Ask to enable scalar renaming (1) or not (0)\n"
10265+ " (default setting: 0).\n"
10266+ " -scalpriv <boolean> Ask to enable scalar privatization (1) or not (0)\n"
10267+ " (default setting: 0).\n"
10268+ " -scalexp <boolean> Ask to enable scalar expansion (1) or not (0)\n"
10269+ " (default setting: 0).\n");
10270 printf(
10271- " -view Ask to display the graphs (1) or not (0)\n"
10272- " (requires dot -graphviz- and gv tools).\n");
10273+ " -view Ask to display the graphs (1) or not (0)\n"
10274+ " (requires dot -graphviz- and gv tools).\n");
10275 printf(
10276- "\nGeneral options:\n"
10277-#ifdef CANDL_SUPPORTS_SCOPLIB
10278- " -inscop Read a .scop formatted file as the input.\n"
10279- " -outscop Output a .scop formatted file as the output.\n"
10280- " -scoptocandl Output a .candl formatted file from a .scop input.\n"
10281-#endif
10282- " -o <output> Name of the output file; 'stdout' is a special\n"
10283- " value: when used, output is standard output\n"
10284- " (default setting: stdout).\n"
10285- " -verbose Display a verbose output.\n"
10286- " -v, --version Display the version information.\n"
10287- " -h, --help Display this information.\n\n"
10288- "The special value 'stdin' for 'file' makes Candl to read data on\n"
10289- "standard input.\n\n"
10290- "For bug reporting or any suggestions, please send an email to the author\n"
10291- "<cedric.bastoul@inria.fr> or to the maintainer of Candl:\n"
10292- "<pouchet@cse.ohio-state.edu>.\n");
10293+ "\nGeneral options:\n"
10294+ " -test <origscop> Test violations with the original scop.\n"
10295+ //" -autocorrect <boolean> Correct violations with a shifting (1) or not(0)\n"
10296+ " -test must be set\n"
10297+ " (default setting: 0).\n"
10298+ " -outscop Output a .scop formatted file as the output.\n"
10299+ " -o <output> Name of the output file; 'stdout' is a special\n"
10300+ " value: when used, output is standard output\n"
10301+ " (default setting: stdout).\n"
10302+ " -verbose Display a verbose output.\n"
10303+ " -v, --version Display the version information.\n"
10304+ " -h, --help Display this information.\n\n"
10305+ "The special value 'stdin' for 'file' makes Candl to read data on standard\n"
10306+ "input.\n"
10307+ "If the -test is not given, the dependences graph of the input 'file' will\n"
10308+ "be computed, otherwise it's the violation graph between 'origscop' and 'file'"
10309+ ".\n\n"
10310+ "For bug reporting or any suggestions, please send an email to the author\n"
10311+ "<cedric.bastoul@inria.fr> or to the maintainer of Candl:\n"
10312+ "<pouchet@cse.ohio-state.edu>.\n");
10313 }
10314
10315
10316@@ -190,32 +183,31 @@ void candl_options_help()
10317 * characters limitation of the ISO C 89 compilers.
10318 * August 5th 2002: first version.
10319 */
10320-void candl_options_version()
10321-{ printf("Candl %s %s bits The Chunky Dependence Analyzer\n",
10322+void candl_options_version() { printf("Candl %s %s bits The Chunky Dependence Analyzer\n",
10323 CANDL_RELEASE,CANDL_VERSION);
10324 printf(
10325- "-----\n"
10326- "Candl is a dependence analyzer for static control programs, coming from \n"
10327- "the CHUNKY project: a research tool for data-locality improvement. This \n"
10328- "program is distributed under the terms of the GNU Lesser General Public\n"
10329- "License (details at http://www.gnu.org/copyleft/gpl.html).\n"
10330- "-----\n");
10331+ "-----\n"
10332+ "Candl is a dependence analyzer for static control programs, coming from \n"
10333+ "the CHUNKY project: a research tool for data-locality improvement. This \n"
10334+ "program is distributed under the terms of the GNU Lesser General Public\n"
10335+ "License (details at http://www.gnu.org/copyleft/gpl.html).\n"
10336+ "-----\n");
10337 printf(
10338- "It would be kind to refer the following paper in any publication "
10339- "resulting \nfrom the use of this software or its library:\n"
10340- "@Article{Bas05,\n"
10341- "author = {Cedric Bastoul and Paul Feautrier},\n"
10342- "title = {Adjusting a program transformation for legality},\n"
10343- "journal = {Parallel Processing Letters},\n"
10344- "year = 2005,\n"
10345- "volume = 15,\n"
10346- "number = 1,\n"
10347- "pages = {3--17},\n"
10348- "month = {March},\n"
10349- "}\n"
10350- "-----\n"
10351- "For bug reporting or any suggestions, please send an email to the author\n"
10352- "<cedric.bastoul@inria.fr>.\n");
10353+ "It would be kind to refer the following paper in any publication "
10354+ "resulting \nfrom the use of this software or its library:\n"
10355+ "@Article{Bas05,\n"
10356+ "author = {Cedric Bastoul and Paul Feautrier},\n"
10357+ "title = {Adjusting a program transformation for legality},\n"
10358+ "journal = {Parallel Processing Letters},\n"
10359+ "year = 2005,\n"
10360+ "volume = 15,\n"
10361+ "number = 1,\n"
10362+ "pages = {3--17},\n"
10363+ "month = {March},\n"
10364+ "}\n"
10365+ "-----\n"
10366+ "For bug reporting or any suggestions, please send an email to the author\n"
10367+ "<cedric.bastoul@inria.fr>.\n");
10368 }
10369
10370
10371@@ -229,20 +221,17 @@ void candl_options_version()
10372 * August 5th 2002: first version.
10373 * June 29th 2003: (debug) lack of argument now detected.
10374 */
10375-void candl_options_set(int * option, int argc, char ** argv, int * number)
10376-{
10377+void candl_options_set(int * option, int argc, char ** argv, int * number) {
10378 char ** endptr;
10379
10380- if (*number+1 >= argc)
10381- {
10382+ if (*number+1 >= argc) {
10383 fprintf(stderr, "[Candl]ERROR: an option lacks of argument.\n");
10384 exit(1);
10385 }
10386
10387 endptr = NULL;
10388 *option = strtol(argv[*number+1],endptr,10);
10389- if (endptr != NULL)
10390- {
10391+ if (endptr != NULL) {
10392 fprintf(stderr, "[Candl]ERROR: %s option value is not valid.\n",
10393 argv[*number]);
10394 exit(1);
10395@@ -254,155 +243,167 @@ void candl_options_set(int * option, int argc, char ** argv, int * number)
10396 /**
10397 * candl_options_read function:
10398 * This functions reads all the options and the input/output files thanks
10399- * the the user's calling line elements (in argc). It fills a CandlOptions
10400+ * the the user's calling line elements (in argc). It fills a candl_options_t
10401 * structure and the FILE structure corresponding to input and output files.
10402 * August 5th 2002: first version.
10403- * April 19th 2003: now in options.c and support of the CandlOptions structure.
10404+ * April 19th 2003: now in options.c and support of the candl_options_t structure.
10405 */
10406 void candl_options_read(int argc, char** argv, FILE** input, FILE** output,
10407- CandlOptions** options)
10408-{
10409- int i, infos = 0, input_is_set = 0;
10410+ FILE **input_test, candl_options_p* options) {
10411+ int i, infos = 0, input_is_set = 0, testscop_is_set = 0;
10412
10413- /* CandlOptions structure allocation and initialization. */
10414+ /* candl_options_t structure allocation and initialization. */
10415 *options = candl_options_malloc();
10416 /* The default output is the standard output. */
10417 *output = stdout;
10418-
10419- for (i = 1; i < argc; i++)
10420- if (argv[i][0] == '-')
10421- {
10422- if (!strcmp(argv[i], "-waw"))
10423- candl_options_set(&(*options)->waw, argc, argv, &i);
10424- else
10425- if (!strcmp(argv[i], "-raw"))
10426- candl_options_set(&(*options)->raw, argc, argv, &i);
10427- else
10428- if (!strcmp(argv[i], "-war"))
10429- candl_options_set(&(*options)->war, argc, argv, &i);
10430- else
10431- if (!strcmp(argv[i], "-rar"))
10432- candl_options_set(&(*options)->rar, argc, argv, &i);
10433- else
10434- if (!strcmp(argv[i], "-commute"))
10435- candl_options_set(&(*options)->commute, argc, argv, &i);
10436- else
10437- if (!strcmp(argv[i], "-fullcheck"))
10438- candl_options_set(&(*options)->fullcheck, argc, argv, &i);
10439- else
10440- if (!strcmp(argv[i], "-depgraph"))
10441- candl_options_set(&(*options)->depgraph, argc, argv, &i);
10442- else
10443- if (!strcmp(argv[i], "-violgraph"))
10444- candl_options_set(&(*options)->violgraph, argc, argv, &i);
10445- else
10446- if (!strcmp(argv[i], "-scalren"))
10447- candl_options_set(&(*options)->scalar_renaming, argc, argv, &i);
10448- else
10449- if (!strcmp(argv[i], "-scalpriv"))
10450- candl_options_set(&(*options)->scalar_privatization, argc, argv, &i);
10451- else
10452- if (!strcmp(argv[i], "-scalexp"))
10453- candl_options_set(&(*options)->scalar_expansion, argc, argv, &i);
10454- else
10455- if (!strcmp(argv[i], "-lastwriter"))
10456- candl_options_set(&(*options)->lastwriter, argc, argv, &i);
10457- else
10458- if (!strcmp(argv[i], "-view"))
10459- (*options)->view = 1;
10460- else
10461- if (!strcmp(argv[i], "-verbose"))
10462- (*options)->verbose = 1;
10463- else
10464- if (!strcmp(argv[i], "-inscop"))
10465- (*options)->readscop = 1;
10466- else
10467- if (!strcmp(argv[i], "-outscop"))
10468- (*options)->writescop = 1;
10469- else
10470- if (!strcmp(argv[i], "-scoptocandl"))
10471- (*options)->scoptocandl = 1;
10472- else
10473- if (!strcmp(argv[i], "-prune-dups"))
10474- (*options)->prune_dups = 1;
10475- else
10476- if ((!strcmp(argv[i], "-struct")) ||
10477- (!strcmp(argv[i], "-structure")))
10478- (*options)->structure = 1;
10479- else
10480- if ((!strcmp(argv[i], "--help")) || (!strcmp(argv[i], "-h")))
10481- {
10482- candl_options_help();
10483- infos = 1;
10484- }
10485- else
10486- if ((!strcmp(argv[i], "--version")) || (!strcmp(argv[i], "-v")))
10487- {
10488- candl_options_version();
10489- infos = 1;
10490- }
10491- else
10492- if (!strcmp(argv[i], "-o"))
10493- {
10494- if (i+1 >= argc)
10495- {
10496- fprintf(stderr,
10497- "[Candl]ERROR: no output name for -o option.\n");
10498- exit(1);
10499- }
10500-
10501- /* stdout is a special value, when used, we set output to standard
10502- * output.
10503- */
10504- if (!strcmp(argv[i+1], "stdout"))
10505- *output = stdout;
10506- else
10507- {
10508- *output = fopen(argv[i+1], "w");
10509- if (*output == NULL)
10510- {
10511- fprintf(stderr,
10512- "[Candl]ERROR: can't create output file %s.\n",
10513- argv[i+1]);
10514- exit(1);
10515- }
10516- }
10517- i++;
10518- }
10519- else
10520- fprintf(stderr, "[Candl]ERROR: unknown %s option.\n", argv[i]);
10521+ *input_test = NULL;
10522+
10523+ for (i = 1; i < argc; i++) {
10524+ if (argv[i][0] == '-') {
10525+ if (!strcmp(argv[i], "-waw")) {
10526+ candl_options_set(&(*options)->waw, argc, argv, &i);
10527+ } else
10528+ if (!strcmp(argv[i], "-raw")) {
10529+ candl_options_set(&(*options)->raw, argc, argv, &i);
10530+ } else
10531+ if (!strcmp(argv[i], "-war")) {
10532+ candl_options_set(&(*options)->war, argc, argv, &i);
10533+ } else
10534+ if (!strcmp(argv[i], "-rar")) {
10535+ candl_options_set(&(*options)->rar, argc, argv, &i);
10536+ } else
10537+ if (!strcmp(argv[i], "-commute")) {
10538+ candl_options_set(&(*options)->commute, argc, argv, &i);
10539+ } else
10540+ if (!strcmp(argv[i], "-fullcheck")) {
10541+ candl_options_set(&(*options)->fullcheck, argc, argv, &i);
10542+ } else
10543+ if (!strcmp(argv[i], "-scalren")) {
10544+ candl_options_set(&(*options)->scalar_renaming, argc, argv, &i);
10545+ } else
10546+ if (!strcmp(argv[i], "-scalpriv")) {
10547+ candl_options_set(&(*options)->scalar_privatization, argc, argv, &i);
10548+ } else
10549+ if (!strcmp(argv[i], "-scalexp")) {
10550+ candl_options_set(&(*options)->scalar_expansion, argc, argv, &i);
10551+ } else
10552+ if (!strcmp(argv[i], "-lastwriter")) {
10553+ candl_options_set(&(*options)->lastwriter, argc, argv, &i);
10554+ } else
10555+ if (!strcmp(argv[i], "-autocorrect")) {
10556+ candl_options_set(&(*options)->autocorrect, argc, argv, &i);
10557+ } else
10558+ if (!strcmp(argv[i], "-view")) {
10559+ (*options)->view = 1;
10560+ } else
10561+ if (!strcmp(argv[i], "-verbose")) {
10562+ (*options)->verbose = 1;
10563+ } else
10564+ if (!strcmp(argv[i], "-outscop")) {
10565+ (*options)->outscop = 1;
10566+ } else
10567+ if (!strcmp(argv[i], "-prune-dups")) {
10568+ (*options)->prune_dups = 1;
10569+ } else
10570+ if ((!strcmp(argv[i], "-struct")) ||
10571+ (!strcmp(argv[i], "-structure"))) {
10572+ (*options)->structure = 1;
10573+ } else
10574+ if ((!strcmp(argv[i], "--help")) || (!strcmp(argv[i], "-h"))) {
10575+ candl_options_help();
10576+ infos = 1;
10577+ } else
10578+ if ((!strcmp(argv[i], "--version")) || (!strcmp(argv[i], "-v"))) {
10579+ candl_options_version();
10580+ infos = 1;
10581+ } else
10582+ if (!strcmp(argv[i], "-o")) {
10583+ i++;
10584+ if (i >= argc) {
10585+ fprintf(stderr,
10586+ "[Candl]ERROR: no output name for -o option.\n");
10587+ exit(1);
10588+ }
10589+
10590+ /* stdout is a special value, when used, we set output to standard
10591+ * output.
10592+ */
10593+ if (!strcmp(argv[i], "stdout")) {
10594+ *output = stdout;
10595+ } else {
10596+ *output = fopen(argv[i], "w");
10597+ if (*output == NULL) {
10598+ fprintf(stderr,
10599+ "[Candl]ERROR: can't create output file %s.\n",
10600+ argv[i]);
10601+ exit(1);
10602+ }
10603+ }
10604+ } else
10605+ if (!strcmp(argv[i], "-test")) {
10606+ i++;
10607+ if (!testscop_is_set) {
10608+ testscop_is_set = i;
10609+ /* stdin is a special value, when used, we set input to
10610+ standard input. */
10611+ if (!strcmp(argv[i], "stdin")) {
10612+ *input_test = stdin;
10613+ } else {
10614+ *input_test = fopen(argv[i], "r");
10615+ if (*input_test == NULL) {
10616+ fprintf(stderr,
10617+ "[Candl]ERROR: %s file does not exist.\n", argv[i]);
10618+ exit(1);
10619+ }
10620+ }
10621+ } else {
10622+ fprintf(stderr, "[Candl]ERROR: multiple input files.\n");
10623+ exit(1);
10624+ }
10625+ } else {
10626+ fprintf(stderr, "[Candl]ERROR: unknown %s option.\n", argv[i]);
10627 }
10628- else
10629- {
10630- if (!input_is_set)
10631- {
10632- input_is_set = 1;
10633- /* stdin is a special value, when used, we set input to
10634- standard input. */
10635- if (!strcmp(argv[i], "stdin"))
10636- *input = stdin;
10637- else
10638- {
10639- *input = fopen(argv[i], "r");
10640- if (*input == NULL)
10641- {
10642- fprintf(stderr,
10643- "[Candl]ERROR: %s file does not exist.\n", argv[i]);
10644- exit(1);
10645- }
10646- }
10647+ }
10648+ else { /* open a file */
10649+ if (!input_is_set) {
10650+ input_is_set = i;
10651+ /* stdin is a special value, when used, we set input to
10652+ standard input. */
10653+ if (!strcmp(argv[i], "stdin")) {
10654+ *input = stdin;
10655+ } else {
10656+ *input = fopen(argv[i], "r");
10657+ if (*input == NULL) {
10658+ fprintf(stderr,
10659+ "[Candl]ERROR: %s file does not exist.\n", argv[i]);
10660+ exit(1);
10661+ }
10662+ }
10663+ } else {
10664+ CANDL_error("multiple input files.\n");
10665 }
10666- else
10667- {
10668- fprintf(stderr, "[Candl]ERROR: multiple input files.\n");
10669- exit(1);
10670 }
10671 }
10672- if (!input_is_set)
10673- {
10674- if (!infos)
10675- fprintf(stderr, "[Candl]ERROR: no input file (-h for help).\n");
10676- exit(1);
10677- }
10678+
10679+ if ((*options)->autocorrect) {
10680+ (*options)->fullcheck = 1;
10681+ if (!*input_test)
10682+ CANDL_error("no test file (-h for help).\n");
10683+ }
10684+
10685+ if (!input_is_set) {
10686+ if (!infos)
10687+ CANDL_error("no input file (-h for help).\n");
10688+ exit(1);
10689+ }
10690+
10691+ if (*input_test && !strcmp(argv[input_is_set], argv[testscop_is_set])) {
10692+ if (!infos)
10693+ CANDL_error("the input file and the test scop can't be the same file.\n");
10694+ exit(1);
10695+ }
10696+
10697+ if (infos)
10698+ exit(0);
10699 }
10700
10701diff --git a/source/piplib-wrapper.c b/source/piplib-wrapper.c
10702index 2ff4bb7..cdd44f3 100644
10703--- a/source/piplib-wrapper.c
10704+++ b/source/piplib-wrapper.c
10705@@ -1,13 +1,13 @@
10706
10707- /**------ ( ----------------------------------------------------------**
10708- ** )\ CAnDL **
10709- **----- / ) --------------------------------------------------------**
10710- ** ( * ( piplib-wrapper.c **
10711- **---- \#/ --------------------------------------------------------**
10712- ** .-"#'-. First version: January 31st 2012 **
10713- **--- |"-.-"| -------------------------------------------------------**
10714- | |
10715- | |
10716+/**------ ( ----------------------------------------------------------**
10717+ ** )\ CAnDL **
10718+ **----- / ) --------------------------------------------------------**
10719+ ** ( * ( piplib-wrapper.c **
10720+ **---- \#/ --------------------------------------------------------**
10721+ ** .-"#'-. First version: January 31st 2012 **
10722+ **--- |"-.-"| -------------------------------------------------------**
10723+ | |
10724+ | |
10725 ******** | | *************************************************************
10726 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
10727 ******************************************************************************
10728@@ -42,16 +42,99 @@
10729 #include <stdio.h>
10730 #include <string.h>
10731 #include <candl/candl.h>
10732+#include <osl/macros.h> /* Need OSL_PRECISION for compatibility with piplib */
10733+#include <osl/relation.h>
10734+#include <candl/macros.h>
10735+#include <candl/piplib.h>
10736
10737
10738-int
10739-pip_has_rational_point(PipMatrix* system,
10740- PipMatrix* context,
10741- int conservative)
10742-{
10743-#ifdef CANDL_HAS_PIPLIB_HYBRID
10744- return piplib_hybrid_has_rational_point(system, context, conservative);
10745-#else
10746+/**
10747+ * pip_relation2matrix function :
10748+ * This function is used to keep the compatibility with Piplib
10749+ */
10750+PipMatrix* pip_relation2matrix(osl_relation_p in) {
10751+ int i, j, precision;
10752+ PipMatrix *out;
10753+
10754+ if (in == NULL)
10755+ return NULL;
10756+
10757+ #ifdef CANDL_LINEAR_VALUE_IS_INT
10758+ precision = OSL_PRECISION_SP;
10759+ #elif defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
10760+ precision = OSL_PRECISION_DP;
10761+ #elif defined(CANDL_LINEAR_VALUE_IS_MP)
10762+ precision = OSL_PRECISION_MP;
10763+ #endif
10764+
10765+ if (precision != in->precision)
10766+ CANDL_error("Precision not compatible with piplib ! (pip_relation2matrix)");
10767+
10768+ out = pip_matrix_alloc(in->nb_rows, in->nb_columns);
10769+
10770+ for (i = 0 ; i < in->nb_rows ; i++) {
10771+ for (j = 0 ; j < in->nb_columns ; j++) {
10772+ #if defined(CANDL_LINEAR_VALUE_IS_INT)
10773+ CANDL_assign(out->p[i][j], in->m[i][j].sp);
10774+ #elif defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
10775+ CANDL_assign(out->p[i][j], in->m[i][j].dp);
10776+ #elif defined(CANDL_LINEAR_VALUE_IS_MP)
10777+ CANDL_assign(out->p[i][j], *((mpz_t*)in->m[i][j].mp));
10778+ #endif
10779+ }
10780+ }
10781+
10782+ return out;
10783+}
10784+
10785+
10786+/**
10787+ * pip_matrix2relation function :
10788+ * This function is used to keep the compatibility with Piplib
10789+ */
10790+osl_relation_p pip_matrix2relation(PipMatrix* in) {
10791+ int i, j, precision;
10792+ osl_relation_p out;
10793+ osl_int_t temp;
10794+
10795+ if (in == NULL)
10796+ return NULL;
10797+
10798+ #if defined(CANDL_LINEAR_VALUE_IS_INT)
10799+ precision = OSL_PRECISION_SP;
10800+ #elif defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
10801+ precision = OSL_PRECISION_DP;
10802+ #elif defined(CANDL_LINEAR_VALUE_IS_MP)
10803+ precision = OSL_PRECISION_MP;
10804+ #endif
10805+
10806+ out = osl_relation_pmalloc(precision, in->NbRows, in->NbColumns);
10807+ osl_int_init(precision, &temp);
10808+
10809+ for (i = 0 ; i < in->NbRows ; i++) {
10810+ for (j = 0 ; j < in->NbColumns ; j++) {
10811+ #ifdef CANDL_LINEAR_VALUE_IS_INT
10812+ temp.sp = in->p[i][j];
10813+ #elif defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
10814+ temp.dp = in->p[i][j];
10815+ #elif defined(CANDL_LINEAR_VALUE_IS_MP)
10816+ mpz_set(*((mpz_t*)temp.mp), in->p[i][j]);
10817+ #endif
10818+ osl_int_assign(precision, &out->m[i][j], temp);
10819+ }
10820+ }
10821+
10822+ osl_int_clear(precision, &temp);
10823+ return out;
10824+}
10825+
10826+int pip_has_rational_point(osl_relation_p system,
10827+ osl_relation_p context,
10828+ int conservative) {
10829+// FIXME : compatibility with osl
10830+//#ifdef CANDL_HAS_PIPLIB_HYBRID
10831+// return piplib_hybrid_has_rational_point(system, context, conservative);
10832+//#else
10833 PipOptions* options;
10834 int ret = 0;
10835 options = pip_options_init ();
10836@@ -59,13 +142,256 @@ pip_has_rational_point(PipMatrix* system,
10837 options->Urs_parms = -1;
10838 options->Urs_unknowns = -1;
10839 options->Nq = 0;
10840- PipQuast* solution = pip_solve (system, context, -1, options);
10841+ PipQuast* solution = pip_solve_osl(system, context, -1, options);
10842 if ((solution != NULL) &&
10843 ((solution->list != NULL) || (solution->condition != NULL)))
10844 ret = 1;
10845- pip_options_free (options);
10846- pip_quast_free (solution);
10847+ pip_options_free(options);
10848+ pip_quast_free(solution);
10849 return ret;
10850-#endif
10851+//#endif
10852 }
10853
10854+
10855+/**
10856+ * pip_solve_osl function :
10857+ * A pip_solve with osl_relation_p instead of PipMatrix
10858+ */
10859+PipQuast* pip_solve_osl(osl_relation_p inequnk, osl_relation_p ineqpar,
10860+ int Bg, PipOptions *options) {
10861+ PipMatrix *pip_unk = pip_relation2matrix(inequnk);
10862+ PipMatrix *pip_par = pip_relation2matrix(ineqpar);
10863+ PipQuast *solution = pip_solve(pip_unk, pip_par, Bg, options);
10864+ if (pip_unk) pip_matrix_free(pip_unk);
10865+ if (pip_par) pip_matrix_free(pip_par);
10866+ return solution;
10867+}
10868+
10869+
10870+/**
10871+ * Return true if the 'size' first elements of 'l1' and 'l2' are equal.
10872+ */
10873+int piplist_are_equal(PipList* l1, PipList* l2, int size) {
10874+ if (l1 == NULL && l2 == NULL)
10875+ return 1;
10876+ if (l1 == NULL || l2 == NULL)
10877+ return 0;
10878+ if (l1->vector == NULL && l2->vector == NULL)
10879+ return 1;
10880+ if (l1->vector == NULL || l2->vector == NULL)
10881+ return 0;
10882+
10883+ int count = 0;
10884+ for (; l1 && l2 && count < size; l1 = l1->next, l2 = l2->next, ++count) {
10885+ if (l1->vector == NULL && l2->vector == NULL)
10886+ return 1;
10887+ if (l1->vector == NULL || l2->vector == NULL)
10888+ return 0;
10889+ if (l1->vector->nb_elements != l2->vector->nb_elements)
10890+ return 0;
10891+ int j;
10892+ for (j = 0; j < l1->vector->nb_elements; ++j)
10893+ if (! CANDL_eq(l1->vector->the_vector[j],
10894+ l2->vector->the_vector[j]) ||
10895+ ! CANDL_eq(l1->vector->the_deno[j],
10896+ l2->vector->the_deno[j]))
10897+ return 0;
10898+ }
10899+
10900+ return 1;
10901+}
10902+
10903+
10904+/*
10905+ * Converts all conditions where the path does not lead to a solution
10906+ * The return is a upip_quast_to_polyhedranion of polyhedra
10907+ * extracted from pip_quast_to_polyhedra
10908+ */
10909+osl_relation_p pip_quast_no_solution_to_polyhedra(PipQuast *quast, int nvar,
10910+ int npar) {
10911+ osl_relation_p ep;
10912+ osl_relation_p tp;
10913+ osl_relation_p qp;
10914+ osl_relation_p iter;
10915+ int precision;
10916+ int j;
10917+ if (quast == NULL)
10918+ return NULL;
10919+
10920+ #if defined(CANDL_LINEAR_VALUE_IS_INT)
10921+ precision = OSL_PRECISION_SP;
10922+ #elif defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
10923+ precision = OSL_PRECISION_DP;
10924+ #elif defined(CANDL_LINEAR_VALUE_IS_MP)
10925+ precision = OSL_PRECISION_MP;
10926+ #endif
10927+
10928+ if (quast->condition != NULL) {
10929+ tp = pip_quast_no_solution_to_polyhedra(quast->next_then, nvar, npar);
10930+ ep = pip_quast_no_solution_to_polyhedra(quast->next_else, nvar, npar);
10931+
10932+ /* Each of the matrices in the then tree needs to be augmented with
10933+ * the condition */
10934+ for (iter = tp ; iter != NULL ; iter = iter->next) {
10935+ int nrows = iter->nb_rows;
10936+ osl_int_set_si(precision, &iter->m[nrows][0], 1);
10937+ for (j = 1; j < 1 + nvar; j++)
10938+ osl_int_set_si(precision, &iter->m[nrows][j], 0);
10939+ for (j = 0; j < npar + 1; j++)
10940+ osl_int_set_si(precision, &iter->m[nrows][1 + nvar + j],
10941+ CANDL_get_si(quast->condition->the_vector[j]));
10942+ (iter->nb_rows)++;
10943+ }
10944+
10945+ for (iter = ep; iter != NULL ; iter = iter->next) {
10946+ int nrows = iter->nb_rows;
10947+ /* Inequality */
10948+ osl_int_set_si(precision, &iter->m[nrows][0], 1);
10949+ for (j = 1; j < 1 + nvar; j++)
10950+ osl_int_set_si(precision, &iter->m[nrows][j], 0);
10951+ for (j = 0; j < npar + 1; j++)
10952+ osl_int_set_si(precision, &iter->m[nrows][1 + nvar + j],
10953+ -CANDL_get_si(quast->condition->the_vector[j]));
10954+ osl_int_decrement(precision,
10955+ &iter->m[nrows][iter->nb_columns - 1],
10956+ iter->m[nrows][iter->nb_columns - 1]);
10957+ (iter->nb_rows)++;
10958+ }
10959+
10960+ /* union of tp and ep */
10961+ if (tp) {
10962+ qp = tp;
10963+ for (iter = tp ; iter->next != NULL ; iter = iter->next)
10964+ ;
10965+ iter->next = ep;
10966+ } else {
10967+ qp = ep;
10968+ }
10969+
10970+ return qp;
10971+
10972+ }
10973+
10974+ if (quast->list != NULL)
10975+ return NULL;
10976+
10977+ /* quast condition is NULL */
10978+ osl_relation_p lwmatrix = osl_relation_pmalloc(precision, nvar+npar+1,
10979+ nvar+npar+2);
10980+ lwmatrix->nb_rows = 0;
10981+ lwmatrix->nb_parameters = npar;
10982+
10983+ return lwmatrix;
10984+}
10985+
10986+
10987+/*
10988+ * Converts a PIP quast to a union of polyhedra
10989+ */
10990+osl_relation_p pip_quast_to_polyhedra(PipQuast *quast, int nvar, int npar) {
10991+ // originaly used for lastwriter
10992+ // july 5th 2012 : extracted from dependence.c
10993+
10994+ osl_relation_p ep;
10995+ osl_relation_p tp;
10996+ osl_relation_p qp;
10997+ osl_relation_p iter;
10998+ int precision;
10999+ int j;
11000+ if (quast == NULL)
11001+ return NULL;
11002+
11003+ #if defined(CANDL_LINEAR_VALUE_IS_INT)
11004+ precision = OSL_PRECISION_SP;
11005+ #elif defined(CANDL_LINEAR_VALUE_IS_LONGLONG)
11006+ precision = OSL_PRECISION_DP;
11007+ #elif defined(CANDL_LINEAR_VALUE_IS_MP)
11008+ precision = OSL_PRECISION_MP;
11009+ #endif
11010+
11011+ if (quast->condition != NULL) {
11012+ tp = pip_quast_to_polyhedra(quast->next_then, nvar, npar);
11013+ ep = pip_quast_to_polyhedra(quast->next_else, nvar, npar);
11014+
11015+ /* Each of the matrices in the then tree needs to be augmented with
11016+ * the condition */
11017+ for (iter = tp ; iter != NULL ; iter = iter->next) {
11018+ int nrows = iter->nb_rows;
11019+ osl_int_set_si(precision, &iter->m[nrows][0], 1);
11020+ for (j = 1; j < 1 + nvar; j++)
11021+ osl_int_set_si(precision, &iter->m[nrows][j], 0);
11022+ for (j = 0; j < npar + 1; j++)
11023+ osl_int_set_si(precision, &iter->m[nrows][1 + nvar + j],
11024+ CANDL_get_si(quast->condition->the_vector[j]));
11025+ (iter->nb_rows)++;
11026+ }
11027+
11028+ /* JP : july 5th 2012:
11029+ * Fix negation of a constraint in adding -1 to the constant
11030+ */
11031+
11032+ for (iter = ep; iter != NULL ; iter = iter->next) {
11033+ int nrows = iter->nb_rows;
11034+ /* Inequality */
11035+ osl_int_set_si(precision, &iter->m[nrows][0], 5);
11036+ for (j = 1; j < 1 + nvar; j++)
11037+ osl_int_set_si(precision, &iter->m[nrows][j], 0);
11038+ for (j = 0; j < npar + 1; j++)
11039+ osl_int_set_si(precision, &iter->m[nrows][1 + nvar + j],
11040+ -CANDL_get_si(quast->condition->the_vector[j]));
11041+ osl_int_decrement(precision,
11042+ &iter->m[nrows][iter->nb_columns - 1],
11043+ iter->m[nrows][iter->nb_columns - 1]);
11044+ (iter->nb_rows)++;
11045+ }
11046+
11047+ /* union of tp and ep */
11048+ if (tp) {
11049+ qp = tp;
11050+ for (iter = tp ; iter->next != NULL ; iter = iter->next)
11051+ ;
11052+ iter->next = ep;
11053+ } else {
11054+ qp = ep;
11055+ }
11056+
11057+ return qp;
11058+
11059+ } else {
11060+ /* quast condition is NULL */
11061+ osl_relation_p lwmatrix = osl_relation_pmalloc(precision, nvar+npar+1,
11062+ nvar+npar+2);
11063+ PipList *vecList = quast->list;
11064+
11065+ int count=0;
11066+ while (vecList != NULL) {
11067+ /* Equality */
11068+ osl_int_set_si(precision, &lwmatrix->m[count][0], 0);
11069+ for (j=0; j < nvar; j++)
11070+ if (j == count)
11071+ osl_int_set_si(precision, &lwmatrix->m[count][j + 1], 1);
11072+ else
11073+ osl_int_set_si(precision, &lwmatrix->m[count][j + 1], 0);
11074+
11075+ for (j=0; j < npar; j++)
11076+ osl_int_set_si(precision, &lwmatrix->m[count][j + 1 + nvar],
11077+ -CANDL_get_si(vecList->vector->the_vector[j]));
11078+ /* Constant portion */
11079+ if (quast->newparm != NULL)
11080+ /* Don't handle newparm for now */
11081+ osl_int_set_si(precision, &lwmatrix->m[count][npar + 1 + nvar],
11082+ -CANDL_get_si(vecList->vector->the_vector[npar+1]));
11083+ else
11084+ osl_int_set_si(precision, &lwmatrix->m[count][npar + 1 + nvar],
11085+ -CANDL_get_si(vecList->vector->the_vector[npar]));
11086+
11087+ count++;
11088+
11089+ vecList = vecList->next;
11090+ }
11091+ lwmatrix->nb_rows = count;
11092+ lwmatrix->nb_parameters = npar;
11093+
11094+ return lwmatrix;
11095+ }
11096+}
11097diff --git a/source/program.c b/source/program.c
11098deleted file mode 100644
11099index 003e753..0000000
11100--- a/source/program.c
11101+++ /dev/null
11102@@ -1,574 +0,0 @@
11103-
11104- /**------ ( ----------------------------------------------------------**
11105- ** )\ CAnDL **
11106- **----- / ) --------------------------------------------------------**
11107- ** ( * ( program.c **
11108- **---- \#/ --------------------------------------------------------**
11109- ** .-"#'-. First version: september 9th 2003 **
11110- **--- |"-.-"| -------------------------------------------------------**
11111- | |
11112- | |
11113- ******** | | *************************************************************
11114- * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
11115- ******************************************************************************
11116- * *
11117- * Copyright (C) 2003-2008 Cedric Bastoul *
11118- * *
11119- * This is free software; you can redistribute it and/or modify it under the *
11120- * terms of the GNU Lesser General Public License as published by the Free *
11121- * Software Foundation; either version 3 of the License, or (at your option) *
11122- * any later version. *
11123- * *
11124- * This software is distributed in the hope that it will be useful, but *
11125- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
11126- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
11127- * for more details. *
11128- * *
11129- * You should have received a copy of the GNU Lesser General Public License *
11130- * along with software; if not, write to the Free Software Foundation, Inc., *
11131- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
11132- * *
11133- * CAnDL, the Chunky Dependence Analyzer *
11134- * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
11135- * *
11136- ******************************************************************************/
11137-
11138-
11139-#include <sys/types.h>
11140-#include <sys/time.h>
11141-#include <sys/resource.h>
11142-#include <stdlib.h>
11143-#include <stdio.h>
11144-#include <string.h>
11145-#include <ctype.h>
11146-
11147-#include <candl/candl.h>
11148-#include <candl/program.h>
11149-
11150-
11151-/******************************************************************************
11152- * Structure display function *
11153- ******************************************************************************/
11154-
11155-/**
11156- * candl_program_print_structure function:
11157- * Displays a candl_program_t structure (program) into a file (file,
11158- * possibly stdout) in a way that trends to be understandable without falling
11159- * in a deep depression or, for the lucky ones, getting a headache... It
11160- * includes an indentation level (level) in order to work with others
11161- * print_structure functions.
11162- * - 09/09/2003: first version.
11163- */
11164-void candl_program_print_structure(FILE* file, candl_program_p program,
11165- int level)
11166-{
11167- int i, j;
11168-
11169- if (program != NULL)
11170- {
11171- /* Go to the right level. */
11172- for (j = 0; j < level; j++)
11173- fprintf(file,"|\t");
11174- fprintf(file,"+-- candl_program_t\n");
11175-
11176- /* A blank line. */
11177- for (j = 0; j <= level + 1; j++)
11178- fprintf(file,"|\t");
11179- fprintf(file,"\n");
11180-
11181- /* Print the context. */
11182- candl_matrix_print_structure(file, program->context, level+1);
11183-
11184- /* A blank line. */
11185- for (j = 0; j <= level+1; j++)
11186- fprintf(file, "|\t");
11187- fprintf(file, "\n");
11188-
11189- /* Go to the right level and print the statement number. */
11190- for (j = 0; j <= level; j++)
11191- fprintf(file, "|\t");
11192- fprintf(file, "Statement number: %d\n", program->nb_statements);
11193-
11194- /* A blank line. */
11195- for (j = 0; j <= level+1; j++)
11196- fprintf(file, "|\t");
11197- fprintf(file, "\n");
11198-
11199- /* Print the statements. */
11200- for (i = 0; i < program->nb_statements; ++i)
11201- candl_statement_print_structure(file, program->statement[i], level+1);
11202-
11203- /* Print the transformation candidate. */
11204- if (program->transformation != NULL)
11205- for (i = 0; i < program->nb_statements; i++)
11206- candl_matrix_print_structure(file, program->transformation[i], level+1);
11207- else
11208- {
11209- /* Go to the right level. */
11210- for (j = 0; j <= level; j++)
11211- fprintf(file, "|\t");
11212- fprintf(file, "+-- No transformation candidate\n");
11213-
11214- /* A blank line. */
11215- for (j = 0; j <= level+1; j++)
11216- fprintf(file, "|\t");
11217- fprintf(file, "\n");
11218- }
11219- }
11220- else
11221- {
11222- /* Go to the right level. */
11223- for (j = 0; j < level; j++)
11224- fprintf(file, "|\t");
11225- fprintf(file, "+-- NULL candl_program_t\n");
11226- }
11227-
11228- /* The last line. */
11229- for (j = 0; j <= level; j++)
11230- fprintf(file, "|\t");
11231- fprintf(file, "\n");
11232-}
11233-
11234-
11235-/**
11236- * candl_program_print function:
11237- * This function prints the content of a candl_program_t structure
11238- * (program) into a file (file, possibly stdout).
11239- */
11240-void candl_program_print(FILE * file, candl_program_p program)
11241-{
11242- candl_program_print_structure(file, program,0);
11243-}
11244-
11245-
11246-
11247-/**
11248- * candl_program_print function:
11249- * This function prints a candl_program_t structure (program) into a
11250- * candl-formatted file (file, possibly stdout).
11251- */
11252-void candl_program_print_candl_file(FILE * file, candl_program_p program)
11253-{
11254- int i, j;
11255-
11256- fprintf (file, "# -------------------\n");
11257- fprintf (file, "# Context\n");
11258- candl_matrix_print_data(file, program->context);
11259- fprintf (file, "\n");
11260- fprintf (file, "# Number of statements\n");
11261- fprintf (file, "%d\n", program->nb_statements);
11262- for (i = 0; i < program->nb_statements; ++i)
11263- {
11264- fprintf (file, "# -------------------\n");
11265- fprintf (file, "# Statement %d\n", i + 1);
11266- fprintf (file, "# Statement type\n");
11267- /* All types set to Assignment. */
11268- fprintf (file, "A\n");
11269- fprintf (file, "\n");
11270- fprintf (file, "# Iteration domain\n");
11271- candl_matrix_print_data(file, program->statement[i]->domain);
11272- fprintf (file, "\n");
11273- fprintf (file, "# Loop labels\n");
11274- for (j = 0; j < program->statement[i]->depth; ++j)
11275- fprintf (file, "%d ", program->statement[i]->index[j]);
11276- fprintf (file, "\n");
11277- fprintf (file, "# Written items\n");
11278- candl_matrix_print_data(file, program->statement[i]->written);
11279- fprintf (file, "\n");
11280- fprintf (file, "# Read items\n");
11281- candl_matrix_print_data(file, program->statement[i]->read);
11282- fprintf (file, "\n");
11283- }
11284- fprintf (file, "# -------------------\n");
11285- fprintf (file, "# Transformation candidate\n");
11286- fprintf (file, "0\n");
11287-}
11288-
11289-
11290-/******************************************************************************
11291- * Memory alloc/dealloc function *
11292- ******************************************************************************/
11293-
11294-
11295-/**
11296- * candl_program_malloc function:
11297- * This function allocates the memory space for a candl_program_t structure and
11298- * sets its fields with default values. Then it returns a pointer to the
11299- * allocated space.
11300- * - 09/12/2005: first version.
11301- */
11302-candl_program_p candl_program_malloc()
11303-{
11304- candl_program_p program;
11305-
11306- /* Memory allocation for the candl_program_t structure. */
11307- program = (candl_program_p)malloc(sizeof(candl_program_t));
11308- if (program == NULL)
11309- CANDL_FAIL("Error: memory overflow");
11310-
11311- /* We set the various fields with default values. */
11312- program->context = NULL;
11313- program->nb_statements = 0;
11314- program->statement = NULL;
11315- program->transformation = NULL;
11316- program->scalars_privatizable = NULL;
11317-
11318- return program;
11319-}
11320-
11321-
11322-/**
11323- * candl_program_free function:
11324- * This function frees the allocated memory for a candl_program_t structure, it
11325- * recursively frees everything inside.
11326- */
11327-void candl_program_free(candl_program_p program)
11328-{
11329- int i;
11330-
11331- candl_matrix_free(program->context);
11332-
11333- if (program->statement != NULL)
11334- {
11335- for (i = 0; i < program->nb_statements; i++)
11336- candl_statement_free(program->statement[i]);
11337- free(program->statement);
11338- }
11339-
11340- if (program->transformation != NULL)
11341- {
11342- for (i = 0; i < program->nb_statements; i++)
11343- candl_matrix_free(program->transformation[i]);
11344- free(program->transformation);
11345- }
11346-
11347- if (program->scalars_privatizable != NULL)
11348- free(program->scalars_privatizable);
11349-
11350- free(program);
11351-}
11352-
11353-
11354-/******************************************************************************
11355- * Reading function *
11356- ******************************************************************************/
11357-
11358-
11359-/**
11360- * candl_program_read function:
11361- * This function reads the informations to put in a candl_program_t
11362- * structure from a file (file, possibly stdin). It returns a pointer
11363- * to a candl_program_t structure containing the read informations.
11364- * September 10th 2003: first version.
11365- */
11366-candl_program_p candl_program_read(FILE * file)
11367-{
11368- int i, nb_statements, nb_parameters, nb_functions;
11369- char s[CANDL_MAX_STRING];
11370- CandlStatement ** statement;
11371- CandlMatrix ** transformation;
11372- candl_program_p program;
11373-
11374- /* Memory allocation for the candl_program_t structure. */
11375- program = candl_program_malloc();
11376-
11377- /* First of all, we read the context data. */
11378- program->context = candl_matrix_read(file);
11379- nb_parameters = program->context->NbColumns - 2;
11380-
11381- /* We read the number of statements. */
11382- while (fgets(s, CANDL_MAX_STRING, file) == 0)
11383- ;
11384- while ((*s=='#'||*s=='\n') || (sscanf(s, " %d", &nb_statements) < 1))
11385- fgets(s, CANDL_MAX_STRING, file);
11386-
11387- program->nb_statements = nb_statements;
11388-
11389- /* Reading of each statement. */
11390- if (nb_statements > 0)
11391- {
11392- /* Memory allocation for the array of pointers to the statements. */
11393- statement = (CandlStatement**) malloc(nb_statements *
11394- sizeof(CandlStatement*));
11395- if (statement == NULL)
11396- CANDL_FAIL("Error: memory overflow");
11397-
11398- for (i = 0; i < nb_statements; i++)
11399- statement[i] = candl_statement_read(file, i, nb_parameters);
11400-
11401- program->statement = statement;
11402- }
11403-
11404- /* We read the number of transformation functions. */
11405- while (fgets(s, CANDL_MAX_STRING, file) == 0)
11406- ;
11407- while ((*s=='#' || *s=='\n') || (sscanf(s, " %d", &nb_functions) < 1))
11408- fgets(s, CANDL_MAX_STRING, file);
11409-
11410- /* Reading of each transformation function. */
11411- if (nb_functions > 0)
11412- {
11413- /* The function number must be the same as statement number. */
11414- if (nb_functions != nb_statements)
11415- {
11416- fprintf(stderr,
11417- "[Candl]ERROR: the numbers of transformations (%d) and "
11418- "statements (%d) differ.\n", nb_functions, nb_statements);
11419- exit(1);
11420- }
11421-
11422- /* Memory allocation for the array of pointers to the functions. */
11423- transformation = (CandlMatrix **)malloc(nb_functions *
11424- sizeof(CandlMatrix *));
11425- if (transformation == NULL)
11426- CANDL_FAIL("Error: memory overflow");
11427-
11428- for (i = 0; i < nb_functions; i++)
11429- transformation[i] = candl_matrix_read(file);
11430-
11431- program->transformation = transformation;
11432- }
11433-
11434- return(program);
11435-}
11436-
11437-
11438-/**
11439- * This function reads the .scop formatted file 'file', check for the
11440- * existence of the <candl> tag in the file, and retrieve the loop
11441- * index information, if any.
11442- * This function is built only if candl was configured with ScopLib support.
11443- *
11444- */
11445-#ifdef CANDL_SUPPORTS_SCOPLIB
11446-static
11447-int** candl_program_scop_get_opt_indices(scoplib_scop_p scop)
11448-{
11449- /* Get the <candl></candl> tag content. */
11450- char* candl_opts = scoplib_scop_tag_content(scop, "<candl>", "</candl>");
11451- if (! candl_opts)
11452- return NULL;
11453- /* Get the <candl><indices></indices></candl> tag content. */
11454- char* indices = scoplib_scop_tag_content_from_string(candl_opts, "<indices>",
11455- "</indices>");
11456- free (candl_opts);
11457- if (! indices)
11458- return NULL;
11459-
11460- /* Tag was found. Scan it. */
11461- int buffer_size = 128;
11462- /* Assume maximum loop nest depth of 128. */
11463- int line[128];
11464- char buff[32];
11465- int** res = malloc(buffer_size * sizeof(int*));
11466- int i, j;
11467- int count, idx = 0;
11468- int line_added = 0;
11469- char* s = indices;
11470-
11471- while (s && *s != '\0')
11472- {
11473- for (i = 0; i < 128; ++i)
11474- {
11475- while (*s != '\0' && *s != '\n' && isspace(*s))
11476- ++s;
11477- if (*s != '\0' && *s != '#' && *s != '\n')
11478- {
11479- for (count = 0; *s >= '0' && *s <= '9'; ++count)
11480- buff[count] = *(s++);
11481- buff[count] = '\0';
11482- line[i] = atoi(buff);
11483- line_added = 1;
11484- }
11485- else
11486- break;
11487- }
11488- if (line_added)
11489- {
11490- if (idx == buffer_size)
11491- res = realloc(res, (buffer_size *= 2) * sizeof(int*));
11492- res[idx] = (int*) malloc(i * sizeof(int));
11493- for (j = 0; j < i; ++j)
11494- res[idx][j] = line[j];
11495- ++idx;
11496- line_added = 0;
11497- }
11498- while (s && *s != '\0' && *s != '\n')
11499- ++s;
11500- if (s && *s != '\0' && *s == '\n')
11501- ++s;
11502- }
11503- res = realloc(res, idx * sizeof(int*));
11504- free (indices);
11505-
11506- return res;
11507-}
11508-#endif
11509-
11510-
11511-/**
11512- * candl_program_read_scop function:
11513- * This function reads the informations to put in a candl_program_t
11514- * structure from a file (file, possibly stdin) following the .scop
11515- * format. It returns a pointer to a candl_program_t structure
11516- * containing the read informations.
11517- * This function is built only if candl was configured with ScopLib support.
11518- *
11519- */
11520-#ifdef CANDL_SUPPORTS_SCOPLIB
11521-candl_program_p candl_program_read_scop(FILE * file)
11522-{
11523- int i;
11524-
11525- /* Read the scop. */
11526- scoplib_scop_p scop = scoplib_scop_read(file);
11527- /* Check for the <candl> tag in the options of the .scop file. */
11528- int** indices = candl_program_scop_get_opt_indices(scop);
11529- /* Convert the scop. */
11530- candl_program_p res = candl_program_convert_scop(scop, indices);
11531-
11532- /* Clean temporary data. */
11533- if (indices)
11534- {
11535- for (i = 0; i < res->nb_statements; ++i)
11536- free(indices[i]);
11537- free(indices);
11538- }
11539- scoplib_scop_free(scop);
11540-
11541- return res;
11542-}
11543-#endif
11544-
11545-
11546-/******************************************************************************
11547- * Processing functions *
11548- ******************************************************************************/
11549-
11550-
11551-/**
11552- * candl_program_convert_scop function:
11553- * This function extracts the useful information of a scoplib_scop_t
11554- * structure to a fresh, independent candl_program_t structure.
11555- * This function is built only if candl was configured with ScopLib support.
11556- *
11557- */
11558-#ifdef CANDL_SUPPORTS_SCOPLIB
11559-candl_program_p candl_program_convert_scop(scoplib_scop_p scop, int** indices)
11560-{
11561- int i, j, k, l;
11562- candl_program_p res = candl_program_malloc();
11563- scoplib_statement_p s = scop->statement;
11564-
11565- /* Duplicate the context. */
11566- res->context = (CandlMatrix*) scoplib_matrix_copy(scop->context);
11567- if (res->context == NULL)
11568- res->context = candl_matrix_malloc(0, 2);
11569-
11570- /* Count the number of statements. */
11571- for (res->nb_statements = 0; s; s = s->next, res->nb_statements++)
11572- ;
11573-
11574- /* Allocate the statements array. */
11575- res->statement = (CandlStatement**) malloc(res->nb_statements *
11576- sizeof(CandlStatement*));
11577-
11578- /* Initialize structures used in iterator indices computation. */
11579- int max = 0;
11580- int max_loop_depth = 128;
11581- int cur_index[max_loop_depth];
11582- int last[max_loop_depth];
11583- for (i = 0; i < max_loop_depth; ++i)
11584- {
11585- cur_index[i] = i;
11586- last[i] = 0;
11587- }
11588- /* Create the statements. */
11589- for (i = 0, s = scop->statement; s; s = s->next, ++i)
11590- {
11591- CandlStatement* statement = candl_statement_malloc();
11592- statement->label = i;
11593- statement->ref = s;
11594- if (s->domain->next != NULL)
11595- CANDL_FAIL("Error: union of domains not supported");
11596-
11597- statement->domain = (CandlMatrix*) scoplib_matrix_copy(s->domain->elt);
11598- /* For the moment, we do not parse the statement to extract its type. */
11599- statement->type = CANDL_ASSIGNMENT;
11600- statement->depth = statement->domain->NbColumns - 2 - scop->nb_parameters;
11601- statement->written = (CandlMatrix*) scoplib_matrix_copy(s->write);
11602- if (statement->written == NULL)
11603- statement->written =
11604- candl_matrix_malloc(0, statement->domain->NbColumns);
11605- statement->read = (CandlMatrix*) scoplib_matrix_copy(s->read);
11606- if (statement->read == NULL)
11607- statement->read = candl_matrix_malloc(0, statement->domain->NbColumns);
11608- statement->index = (int*) malloc(statement->depth * sizeof(int));
11609- if (indices != NULL)
11610- /* Iterator indices are provided. */
11611- for (j = 0; j < statement->depth; ++j)
11612- statement->index[j] = indices[i][j];
11613- else
11614- {
11615- /* Iterator indices must be computed from the scattering matrix. */
11616- scoplib_matrix_p m = s->schedule;
11617- if (m == NULL)
11618- CANDL_FAIL("Error: No scheduling matrix and no loop "
11619- "indices specification");
11620-
11621- /* FIXME: Sort the statements in their execution order. */
11622- /* It must be a 2d+1 identity scheduling matrix, and
11623- statements must be sorted in their execution order. */
11624- /* Check that it is a identity matrix. */
11625- int error = 0;
11626- if (m->NbRows != 2 * statement->depth + 1)
11627- error = 1;
11628- else
11629- for (l = 0; l < m->NbRows; ++l)
11630- {
11631- for (k = 1; k < m->NbColumns - 1; ++k)
11632- switch (CANDL_get_si(m->p[l][k]))
11633- {
11634- case 0:
11635- if (l % 2 && k == (l / 2) + 1) error = 1;
11636- break;
11637- case 1:
11638- if ((l % 2 && k != (l / 2) + 1) || (! l % 2)) error = 1;
11639- break;
11640- default:
11641- error = 1;
11642- break;
11643- }
11644- if (l % 2 && CANDL_get_si(m->p[l][k]))
11645- error = 1;
11646- }
11647- if (error)
11648- CANDL_FAIL("Error: schedule is not identity 2d+1 shaped.\n"
11649- "Consider using the <indices> option tag to declare "
11650- " iterator indices");
11651-
11652- /* Compute the value of the iterator indices. */
11653- for (j = 0; j < statement->depth; ++j)
11654- {
11655- int val = CANDL_get_si(m->p[2 * j][m->NbColumns - 1]);
11656- if (last[j] < val)
11657- {
11658- last[j] = val;
11659- for (k = j + 1; k < max_loop_depth; ++k)
11660- last[k] = 0;
11661- for (k = j; k < max_loop_depth; ++k)
11662- cur_index[k] = max + (k - j) + 1;
11663- break;
11664- }
11665- }
11666- for (j = 0; j < statement->depth; ++j)
11667- statement->index[j] = cur_index[j];
11668- max = max < cur_index[j - 1] ? cur_index[j - 1] : max;
11669- }
11670- /* Store the statement. */
11671- res->statement[i] = statement;
11672- }
11673-
11674- return res;
11675-}
11676-#endif
11677diff --git a/source/pruning.c b/source/pruning.c
11678index 2b0cf49..db4a90f 100644
11679--- a/source/pruning.c
11680+++ b/source/pruning.c
11681@@ -6,8 +6,8 @@
11682 **---- \#/ --------------------------------------------------------**
11683 ** .-"#'-. First version: July 17th 2011 **
11684 **--- |"-.-"| -------------------------------------------------------**
11685- | |
11686- | |
11687+ | |
11688+ | |
11689 ******** | | *************************************************************
11690 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
11691 ******************************************************************************
11692@@ -40,35 +40,15 @@
11693 #include <stdlib.h>
11694 #include <stdio.h>
11695 #include <string.h>
11696-#include <candl/candl.h>
11697-
11698 #include <assert.h>
11699+#include <osl/statement.h>
11700+#include <osl/relation.h>
11701+#include <candl/statement.h>
11702+#include <candl/dependence.h>
11703
11704
11705-/**
11706- * Return true if the 2 matrices are strictly identical.
11707- */
11708-static
11709-int candl_matrix_equal(CandlMatrix* m1, CandlMatrix* m2)
11710-{
11711- int i, j;
11712+#if defined(CANDL_COMPILE_PRUNNING_C)
11713
11714- if (m1 == NULL)
11715- {
11716- if (m2 == NULL)
11717- return 1;
11718- return 0;
11719- }
11720-
11721- if (m1->NbRows != m2->NbRows || m1->NbColumns != m2->NbColumns)
11722- return 0;
11723-
11724- for (i = 0; i < m1->NbRows; ++i)
11725- for (j = 0; j < m1->NbColumns; ++j)
11726- if (! CANDL_eq(m1->p[i][j], m2->p[i][j]))
11727- return 0;
11728- return 1;
11729-}
11730
11731 #define BUFF_SIZE 1024
11732
11733@@ -79,79 +59,69 @@ int candl_matrix_equal(CandlMatrix* m1, CandlMatrix* m2)
11734 * Paths are stored as list of lists of dependences in 'paths_list'.
11735 */
11736 static
11737-void find_paths_rec (int tgt_id, int cur_length, int max_length,
11738- int final_id,
11739- CandlDependence** alldeps,
11740- CandlDependence** cur_path,
11741- CandlDependence**** paths_list)
11742-{
11743+void find_paths_rec(int tgt_id, int cur_length, int max_length,
11744+ int final_id,
11745+ osl_dependence_p* alldeps,
11746+ osl_dependence_p* cur_path,
11747+ osl_dependence_p*** paths_list) {
11748 int i;
11749
11750- for (i = 0; alldeps[i]; ++i)
11751- {
11752- if (alldeps[i]->usr == NULL)
11753- {
11754- if (alldeps[i]->source->label == tgt_id)
11755- {
11756- // Ensure the path flow is consistent.
11757- if (cur_length > 1)
11758- {
11759- if (cur_path[cur_length - 1]->type == CANDL_RAW ||
11760- cur_path[cur_length - 1]->type == CANDL_RAW_SCALPRIV ||
11761- cur_path[cur_length - 1]->type == CANDL_RAR)
11762- {
11763- // RAW or RAR.
11764- if (alldeps[i]->type != CANDL_RAR &&
11765- alldeps[i]->type != CANDL_WAR)
11766- continue;
11767- }
11768- else
11769- {
11770- // WAW or WAR.
11771- if (alldeps[i]->type != CANDL_WAW &&
11772- alldeps[i]->type != CANDL_RAW)
11773- continue;
11774- }
11775- }
11776- if (cur_length + 1 == max_length)
11777- {
11778- if (alldeps[i]->target->label == final_id)
11779- {
11780- // Found a path.
11781- int j, pos;
11782- for (pos = 0; (*paths_list)[pos]; ++pos)
11783- ;
11784- if (pos + 1 % BUFF_SIZE == 0)
11785- {
11786- *paths_list = (CandlDependence***)
11787- realloc(*paths_list, sizeof(CandlDependence**) *
11788- (BUFF_SIZE + pos + 1));
11789- *paths_list[pos + 1] = NULL;
11790- }
11791- (*paths_list)[pos] = (CandlDependence**)
11792- malloc((max_length + 1) * sizeof(CandlDependence*));
11793- for (j = 0; j < max_length - 1; ++j)
11794- (*paths_list)[pos][j] = cur_path[j];
11795- (*paths_list)[pos][j++] = alldeps[i];
11796- (*paths_list)[pos][j] = NULL;
11797- }
11798- }
11799- else
11800- {
11801- // Store the current node in the path.
11802- cur_path[cur_length] = alldeps[i];
11803- // Mark the dependence as processed.
11804- alldeps[i]->usr = alldeps[i];
11805- // Look for the next node.
11806- find_paths_rec (alldeps[i]->target->label, cur_length + 1,
11807- max_length, final_id, alldeps, cur_path,
11808- paths_list);
11809- // Reset the dependence.
11810- alldeps[i]->usr = NULL;
11811- }
11812- }
11813- }
11814+ for (i = 0; alldeps[i]; ++i) {
11815+ if (alldeps[i]->usr == NULL) {
11816+ ((candl_statement_usr_p)target->usr)->label
11817+ if (alldeps[i]->((candl_statement_usr_p)source->usr)->label == tgt_id) {
11818+ // Ensure the path flow is consistent.
11819+ if (cur_length > 1) {
11820+ if (cur_path[cur_length - 1]->type == CANDL_RAW ||
11821+ cur_path[cur_length - 1]->type == CANDL_RAW_SCALPRIV ||
11822+ cur_path[cur_length - 1]->type == CANDL_RAR) {
11823+ // RAW or RAR.
11824+ if (alldeps[i]->type != CANDL_RAR &&
11825+ alldeps[i]->type != CANDL_WAR)
11826+ continue;
11827+ }
11828+ else {
11829+ // WAW or WAR.
11830+ if (alldeps[i]->type != CANDL_WAW &&
11831+ alldeps[i]->type != CANDL_RAW)
11832+ continue;
11833+ }
11834+ }
11835+ if (cur_length + 1 == max_length) {
11836+ if (alldeps[i]->((candl_statement_usr_p)target->usr)->label == final_id) {
11837+ // Found a path.
11838+ int j, pos;
11839+ for (pos = 0; (*paths_list)[pos]; ++pos)
11840+ ;
11841+ if (pos + 1 % BUFF_SIZE == 0) {
11842+ *paths_list = (osl_dependence_p**)
11843+ realloc(*paths_list, sizeof(osl_dependence_p*) *
11844+ (BUFF_SIZE + pos + 1));
11845+ *paths_list[pos + 1] = NULL;
11846+ }
11847+ (*paths_list)[pos] = (osl_dependence_p*)
11848+ malloc((max_length + 1) * sizeof(osl_dependence_p));
11849+ for (j = 0; j < max_length - 1; ++j)
11850+ (*paths_list)[pos][j] = cur_path[j];
11851+ (*paths_list)[pos][j++] = alldeps[i];
11852+ (*paths_list)[pos][j] = NULL;
11853+ }
11854+ }
11855+ else {
11856+ // Store the current node in the path.
11857+ cur_path[cur_length] = alldeps[i];
11858+ // Mark the dependence as processed.
11859+ alldeps[i]->usr = alldeps[i];
11860+ // Look for the next node.
11861+ find_paths_rec(alldeps[i]->((candl_statement_usr_p)target->usr)->label,
11862+ cur_length + 1, max_length, final_id, alldeps,
11863+ cur_path, paths_list);
11864+ // Reset the dependence.
11865+ alldeps[i]->usr = NULL;
11866+ }
11867+ }
11868 }
11869+ }
11870 }
11871
11872
11873@@ -162,91 +132,55 @@ void find_paths_rec (int tgt_id, int cur_length, int max_length,
11874 * 'target->label'.
11875 */
11876 static
11877-CandlDependence***
11878-find_dep_paths (CandlDependence** ardeps,
11879- CandlStatement* source,
11880- CandlStatement*target)
11881-{
11882+osl_dependence_p** find_dep_paths(osl_dependence_p* ardeps,
11883+ osl_statement_p source,
11884+ osl_statement_p target) {
11885 int i, nb_dep;
11886 for (nb_dep = 0; ardeps[nb_dep]; ++nb_dep)
11887 ;
11888 if (nb_dep < 2)
11889 return NULL;
11890- CandlDependence* cur_path[nb_dep + 1];
11891- CandlDependence*** paths_list =
11892- (CandlDependence***)malloc(BUFF_SIZE * sizeof(CandlDependence**));
11893+ osl_dependence_p *cur_path =
11894+ (osl_dependence_p*) malloc(sizeof(osl_dependence_p) *
11895+ (nb_dep + 1));
11896+ osl_dependence_p** paths_list =
11897+ (osl_dependence_p**)malloc(BUFF_SIZE * sizeof(osl_dependence_p*));
11898 for (i = 0; i < BUFF_SIZE; ++i)
11899 paths_list[i] = NULL;
11900 // Iterate on all possible paths length, from Sx to Sy, of length y-x.
11901- for (i = 2; i <= target->label - source->label; ++i)
11902- find_paths_rec (source->label, 0, i, target->label, ardeps, cur_path,
11903- &paths_list);
11904-
11905+ for (i = 2; i <= ((candl_statement_usr_p)target->usr)->label -
11906+ ((candl_statement_usr_p)source->usr)->label; ++i)
11907+ find_paths_rec(((candl_statement_usr_p)source->usr)->label, 0, i,
11908+ ((candl_statement_usr_p)target->usr)->label, ardeps,
11909+ cur_path, &paths_list);
11910+ free(cur_path);
11911 return paths_list;
11912 }
11913
11914-/**
11915- * Return true if the 'size' first elements of 'l1' and 'l2' are equal.
11916- */
11917-static
11918-int piplist_are_equal (PipList* l1, PipList* l2, int size)
11919-{
11920- if (l1 == NULL && l2 == NULL)
11921- return 1;
11922- if (l1 == NULL || l2 == NULL)
11923- return 0;
11924- if (l1->vector == NULL && l2->vector == NULL)
11925- return 1;
11926- if (l1->vector == NULL || l2->vector == NULL)
11927- return 0;
11928-
11929- int count = 0;
11930- for (; l1 && l2 && count < size; l1 = l1->next, l2 = l2->next, ++count)
11931- {
11932- if (l1->vector == NULL && l2->vector == NULL)
11933- return 1;
11934- if (l1->vector == NULL || l2->vector == NULL)
11935- return 0;
11936- if (l1->vector->nb_elements != l2->vector->nb_elements)
11937- return 0;
11938- int j;
11939- for (j = 0; j < l1->vector->nb_elements; ++j)
11940- if (! CANDL_eq(l1->vector->the_vector[j],
11941- l2->vector->the_vector[j]) ||
11942- ! CANDL_eq(l1->vector->the_deno[j],
11943- l2->vector->the_deno[j]))
11944- return 0;
11945- }
11946-
11947- return 1;
11948-}
11949
11950 /**
11951 * Return true if the 'size' first variables in a quast are strictly
11952 * equal.
11953 */
11954 static
11955-int
11956-quast_are_equal (PipQuast* q1, PipQuast* q2, int size)
11957-{
11958+int quast_are_equal (PipQuast* q1, PipQuast* q2, int size) {
11959 if (q1 == NULL && q2 == NULL)
11960 return 1;
11961 if (q1 == NULL || q2 == NULL)
11962 return 0;
11963
11964 // Inspect conditions.
11965- if (q1->condition != NULL && q2->condition != NULL)
11966- {
11967- PipList c1; c1.next = NULL; c1.vector = q1->condition;
11968- PipList c2; c2.next = NULL; c2.vector = q2->condition;
11969- if (! piplist_are_equal(&c1, &c2, size))
11970- return 0;
11971- return quast_are_equal (q1->next_then, q2->next_then, size) &&
11972- quast_are_equal (q1->next_else, q2->next_else, size);
11973- }
11974+ if (q1->condition != NULL && q2->condition != NULL) {
11975+ PipList c1; c1.next = NULL; c1.vector = q1->condition;
11976+ PipList c2; c2.next = NULL; c2.vector = q2->condition;
11977+ if (! piplist_are_equal(&c1, &c2, size))
11978+ return 0;
11979+ return quast_are_equal(q1->next_then, q2->next_then, size) &&
11980+ quast_are_equal(q1->next_else, q2->next_else, size);
11981+ }
11982 if (q1->condition != NULL || q2->condition != NULL)
11983 return 0;
11984- return piplist_are_equal (q1->list, q2->list, size);
11985+ return piplist_are_equal(q1->list, q2->list, size);
11986 }
11987
11988 /**
11989@@ -256,9 +190,7 @@ quast_are_equal (PipQuast* q1, PipQuast* q2, int size)
11990 * corresponding to loop iterators).
11991 */
11992 static
11993-int
11994-is_covering (CandlDependence* dep, CandlDependence** path)
11995-{
11996+int is_covering(osl_dependence_p dep, osl_dependence_p* path) {
11997 int i, path_length;
11998
11999 for (path_length = 0; path[path_length]; ++path_length)
12000@@ -267,170 +199,154 @@ is_covering (CandlDependence* dep, CandlDependence** path)
12001 /// FIXME: This may be overly conservative.
12002 // Check the path extremal points type.
12003 if (dep->type == CANDL_RAW || dep->type == CANDL_RAW_SCALPRIV
12004- || dep->type == CANDL_WAW)
12005- {
12006- // RAW or WAW.
12007- if (path[0]->type != CANDL_RAW && path[0]->type != CANDL_RAW_SCALPRIV &&
12008- path[0]->type != CANDL_WAW)
12009- return 0;
12010- if (dep->type == CANDL_RAW || dep->type == CANDL_RAW_SCALPRIV)
12011- if (path[path_length - 1]->type != CANDL_RAW &&
12012- path[path_length - 1]->type != CANDL_RAW_SCALPRIV &&
12013- path[path_length - 1]->type != CANDL_RAR)
12014- return 0;
12015- if (dep->type == CANDL_WAW)
12016- if (path[path_length - 1]->type != CANDL_WAR &&
12017- path[path_length - 1]->type != CANDL_WAW)
12018- return 0;
12019- }
12020- else
12021- {
12022- // WAR or RAR.
12023- if (path[0]->type != CANDL_WAR && path[0]->type != CANDL_RAR)
12024- return 0;
12025- if (dep->type == CANDL_WAR)
12026- if (path[path_length - 1]->type != CANDL_WAW &&
12027- path[path_length - 1]->type != CANDL_WAR)
12028- return 0;
12029- if (dep->type == CANDL_RAR)
12030- if (path[path_length - 1]->type != CANDL_RAR &&
12031- path[path_length - 1]->type != CANDL_RAW_SCALPRIV &&
12032- path[path_length - 1]->type != CANDL_RAW)
12033- return 0;
12034- }
12035+ || dep->type == CANDL_WAW) {
12036+ // RAW or WAW.
12037+ if (path[0]->type != CANDL_RAW && path[0]->type != CANDL_RAW_SCALPRIV &&
12038+ path[0]->type != CANDL_WAW)
12039+ return 0;
12040+ if (dep->type == CANDL_RAW || dep->type == CANDL_RAW_SCALPRIV)
12041+ if (path[path_length - 1]->type != CANDL_RAW &&
12042+ path[path_length - 1]->type != CANDL_RAW_SCALPRIV &&
12043+ path[path_length - 1]->type != CANDL_RAR)
12044+ return 0;
12045+ if (dep->type == CANDL_WAW)
12046+ if (path[path_length - 1]->type != CANDL_WAR &&
12047+ path[path_length - 1]->type != CANDL_WAW)
12048+ return 0;
12049+ }
12050+ else {
12051+ // WAR or RAR.
12052+ if (path[0]->type != CANDL_WAR && path[0]->type != CANDL_RAR)
12053+ return 0;
12054+ if (dep->type == CANDL_WAR)
12055+ if (path[path_length - 1]->type != CANDL_WAW &&
12056+ path[path_length - 1]->type != CANDL_WAR)
12057+ return 0;
12058+ if (dep->type == CANDL_RAR)
12059+ if (path[path_length - 1]->type != CANDL_RAR &&
12060+ path[path_length - 1]->type != CANDL_RAW_SCALPRIV &&
12061+ path[path_length - 1]->type != CANDL_RAW)
12062+ return 0;
12063+ }
12064
12065 // a- Fast check. Ensure the dependence depth is consistent across
12066 // the path. We may correctly cover _more_ points and still have a
12067 // perfect transitive cover.
12068 /// FIXME: ambiguous test?
12069-/* for (i = 0; i < path_length; ++i) */
12070-/* if (path[i]->depth > dep->depth) */
12071-/* return 0; */
12072+ /* for (i = 0; i < path_length; ++i) */
12073+ /* if (path[i]->depth > dep->depth) */
12074+ /* return 0; */
12075
12076 // b- Check the covering property. Works only if
12077 // the iterator part of iteration domains and access functions are
12078 // unimodular matrices.
12079 // Build a large system with all dependences.
12080- int nb_par = path[0]->source->domain->NbColumns - path[0]->source->depth - 2;
12081+ int nb_par = path[0]->domain->nb_parameters;
12082 int nb_iters = 0;
12083 int nb_rows = 0;
12084- for (i = 0; i < path_length; ++i)
12085- {
12086- nb_iters += path[i]->domain->NbColumns - nb_par - 2;
12087- nb_rows += path[i]->domain->NbRows;
12088- if (i > 0)
12089- nb_iters -= path[i]->source->depth;
12090- }
12091- CandlMatrix* syst = candl_matrix_malloc (nb_rows, nb_iters + nb_par + 2);
12092+ for (i = 0; i < path_length; ++i) {
12093+ nb_iters += path[i]->source_nb_output_dims_domain +
12094+ path[i]->target_nb_output_dims_domain;
12095+ nb_rows += path[i]->domain->nb_rows;
12096+ if (i > 0)
12097+ nb_iters -= ((candl_statement_usr_p) path[i]->source->usr)->depth;
12098+ }
12099+
12100+ CandlMatrix* syst = candl_matrix_malloc(nb_rows, nb_iters + nb_par + 2);
12101 int pos = 0;
12102 int j, k;
12103 int iter_off = 0;
12104- for (k = 0; k < path_length; ++k)
12105- {
12106- for (i = 0; i < path[k]->domain->NbRows; ++i)
12107- {
12108- CANDL_assign(syst->p[pos][0], path[k]->domain->p[i][0]);
12109- for (j = 1; j < path[k]->domain->NbColumns - 1 - nb_par; ++j)
12110- CANDL_assign(syst->p[pos][j + iter_off], path[k]->domain->p[i][j]);
12111- for (; j < path[k]->domain->NbColumns; ++j)
12112- {
12113- int parpos = j - (path[k]->domain->NbColumns - 1 - nb_par) +
12114- syst->NbColumns - nb_par - 1;
12115- CANDL_assign(syst->p[pos][parpos], path[k]->domain->p[i][j]);
12116- }
12117- ++pos;
12118- }
12119- iter_off += path[k]->source->depth;
12120+ for (k = 0; k < path_length; ++k) {
12121+ for (i = 0; i < path[k]->domain->NbRows; ++i) {
12122+ CANDL_assign(syst->p[pos][0], path[k]->domain->p[i][0]);
12123+ for (j = 1; j < path[k]->domain->NbColumns - 1 - nb_par; ++j)
12124+ CANDL_assign(syst->p[pos][j + iter_off], path[k]->domain->p[i][j]);
12125+ for (; j < path[k]->domain->NbColumns; ++j) {
12126+ int parpos = j - (path[k]->domain->NbColumns - 1 - nb_par) +
12127+ syst->NbColumns - nb_par - 1;
12128+ CANDL_assign(syst->p[pos][parpos], path[k]->domain->p[i][j]);
12129+ }
12130+ ++pos;
12131 }
12132+ iter_off += path[k]->source->depth;
12133+ }
12134
12135 // Algo:
12136 // lexmin(dep, R) == lexmin(path, R) && lexmax(dep, R) == lexmax(path, R) &&
12137 // lexmin(dep, S) == lexmin(path, S) && lexmax(dep, S) == lexmax(path, S)
12138 PipOptions* options;
12139- options = pip_options_init ();
12140+ options = pip_options_init();
12141 options->Simplify = 1;
12142 options->Urs_parms = -1;
12143 options->Urs_unknowns = -1;
12144- CandlMatrix* context = candl_matrix_malloc (0, nb_par + 2);
12145- PipQuast* qpath = pip_solve (syst, context, -1, options);
12146- PipQuast* qdep = pip_solve (dep->domain, context, -1, options);
12147- int are_equal = quast_are_equal (qpath, qdep, dep->source->depth);
12148- if (are_equal)
12149- {
12150- pip_quast_free (qpath);
12151- pip_quast_free (qdep);
12152- options->Maximize = 1;
12153- qpath = pip_solve (syst, context, -1, options);
12154- qdep = pip_solve (dep->domain, context, -1, options);
12155- are_equal = quast_are_equal (qpath, qdep, dep->source->depth);
12156+ CandlMatrix* context = candl_matrix_malloc(0, nb_par + 2);
12157+ PipQuast* qpath = pip_solve(syst, context, -1, options);
12158+ PipQuast* qdep = pip_solve(dep->domain, context, -1, options);
12159+ int are_equal = quast_are_equal(qpath, qdep, dep->source->depth);
12160+ if (are_equal) {
12161+ pip_quast_free (qpath);
12162+ pip_quast_free (qdep);
12163+ options->Maximize = 1;
12164+ qpath = pip_solve(syst, context, -1, options);
12165+ qdep = pip_solve(dep->domain, context, -1, options);
12166+ are_equal = quast_are_equal(qpath, qdep, dep->source->depth);
12167+ }
12168+ if (are_equal) {
12169+ pip_quast_free(qpath);
12170+ pip_quast_free(qdep);
12171+ options->Maximize = 0;
12172+ // Permute columns for first and last iterators.
12173+ for (i = 0; i < dep->target->depth; ++i) {
12174+ for (j = 0; j < syst->NbRows; ++j) {
12175+ int tmp = CANDL_get_si(syst->p[j][1]);
12176+ int pos = syst->NbColumns - 1 - nb_par - dep->target->depth + i;
12177+ CANDL_assign(syst->p[j][1], syst->p[j][pos]);
12178+ CANDL_set_si(syst->p[j][pos], tmp);
12179+ }
12180 }
12181- if (are_equal)
12182- {
12183- pip_quast_free (qpath);
12184- pip_quast_free (qdep);
12185- options->Maximize = 0;
12186- // Permute columns for first and last iterators.
12187- for (i = 0; i < dep->target->depth; ++i)
12188- {
12189- for (j = 0; j < syst->NbRows; ++j)
12190- {
12191- int tmp = CANDL_get_si(syst->p[j][1]);
12192- int pos = syst->NbColumns - 1 - nb_par - dep->target->depth + i;
12193- CANDL_assign(syst->p[j][1], syst->p[j][pos]);
12194- CANDL_set_si(syst->p[j][pos], tmp);
12195- }
12196- }
12197- qpath = pip_solve (syst, context, -1, options);
12198- qdep = pip_solve (dep->domain, context, -1, options);
12199- are_equal = quast_are_equal (qpath, qdep, dep->target->depth);
12200- }
12201- if (are_equal)
12202- {
12203- pip_quast_free (qpath);
12204- pip_quast_free (qdep);
12205- options->Maximize = 1;
12206- qpath = pip_solve (syst, context, -1, options);
12207- qdep = pip_solve (dep->domain, context, -1, options);
12208- are_equal = quast_are_equal (qpath, qdep, dep->target->depth);
12209- }
12210-
12211- pip_options_free (options);
12212- pip_quast_free (qpath);
12213- pip_quast_free (qdep);
12214- pip_matrix_free (syst);
12215+ qpath = pip_solve(syst, context, -1, options);
12216+ qdep = pip_solve(dep->domain, context, -1, options);
12217+ are_equal = quast_are_equal(qpath, qdep, dep->target->depth);
12218+ }
12219+ if (are_equal) {
12220+ pip_quast_free(qpath);
12221+ pip_quast_free(qdep);
12222+ options->Maximize = 1;
12223+ qpath = pip_solve(syst, context, -1, options);
12224+ qdep = pip_solve(dep->domain, context, -1, options);
12225+ are_equal = quast_are_equal(qpath, qdep, dep->target->depth);
12226+ }
12227+
12228+ pip_options_free(options);
12229+ pip_quast_free(qpath);
12230+ pip_quast_free(qdep);
12231+ pip_matrix_free(syst);
12232
12233 return are_equal;
12234 }
12235
12236 static
12237-int
12238-is_iter_unimodular (CandlDependence* dep)
12239-{
12240+int is_iter_unimodular(osl_dependence_p dep) {
12241 // Check unimodular on the iterator part.
12242 int i, j;
12243- for (i = 0; i < dep->domain->NbRows; ++i)
12244- {
12245- if (i < dep->source->domain->NbRows ||
12246- i > dep->source->domain->NbRows + dep->target->domain->NbRows)
12247- {
12248- for (j = 1; j <= dep->source->depth; ++j)
12249- {
12250- int val = CANDL_get_si(dep->domain->p[i][j]);
12251- if (val < -1 || val > 1)
12252- return 0;
12253- }
12254- }
12255- else if (i < dep->source->domain->NbRows +
12256- dep->target->domain->NbRows ||
12257- i > dep->source->domain->NbRows + dep->target->domain->NbRows)
12258- {
12259- for (j = 1; j <= dep->source->depth; ++j)
12260- {
12261- int val = CANDL_get_si(dep->domain->p[i][j + dep->source->depth]);
12262- if (val < -1 || val > 1)
12263- return 0;
12264- }
12265- }
12266+ int n;
12267+ int precision = dep->domain->precision;
12268+ osl_relation_p matrix;
12269+
12270+ matrix = dep->source->domain;
12271+ for (i = 0 ; i < matrix->nb_rows ; i++)
12272+ for (j = 1 ; j <= matrix->nb_output_dims ; j++) {
12273+ n = osl_int_get_si(precision, matrix->m[i][j]);
12274+ if (n < -1 || n > 1)
12275+ return 0;
12276+ }
12277+
12278+ matrix = dep->target->domain;
12279+ for (i = 0 ; i < matrix->nb_rows ; i++)
12280+ for (j = 1 ; j <= matrix->nb_output_dims ; j++) {
12281+ n = osl_int_get_si(precision, matrix->m[i][j]);
12282+ if (n < -1 || n > 1)
12283+ return 0;
12284 }
12285
12286 return 1;
12287@@ -441,157 +357,169 @@ is_iter_unimodular (CandlDependence* dep)
12288 * In-place modification of the list of dependence polyhedra.
12289 *
12290 */
12291-CandlDependence*
12292-candl_dependence_prune_transitively_covered (CandlDependence* deps)
12293-{
12294- CandlDependence* tmp;
12295+osl_dependence_p osl_dependence_prune_transitively_covered(
12296+ osl_dependence_p deps) {
12297+ if (deps == NULL)
12298+ return NULL;
12299+
12300+ osl_dependence_p tmp;
12301+ osl_dependence_p *ardeps;
12302+ osl_relation_p srcmat;
12303+ osl_relation_p *allarrays;
12304+ osl_dependence_p** path;
12305+ osl_dependence_p *curardeps;
12306+ candl_statement_usr_p s_usr, t_usr;
12307+ int precision = deps->domain->precision;
12308+ int nb_deps;
12309
12310 // 1- Collect all arrays that occur in dependences.
12311 int cnt, i, j, k, l;
12312 int nb_stmts = 0;
12313- for (tmp = deps, cnt = 0; tmp; tmp = tmp->next)
12314- {
12315- nb_stmts = tmp->source->label > nb_stmts ? tmp->source->label : nb_stmts;
12316- nb_stmts = tmp->target->label > nb_stmts ? tmp->target->label : nb_stmts;
12317- ++cnt;
12318- }
12319+ for (tmp = deps, cnt = 0; tmp; tmp = tmp->next) {
12320+ s_usr = tmp->source->usr;
12321+ t_usr = tmp->target->usr;
12322+ nb_stmts = s_usr->label > nb_stmts ? s_usr->label : nb_stmts;
12323+ nb_stmts = t_usr->label > nb_stmts ? t_usr->label : nb_stmts;
12324+ ++cnt;
12325+ }
12326 ++nb_stmts;
12327- int nb_deps = cnt;
12328- int allarrays[cnt];
12329- for (tmp = deps, cnt = 0; tmp; tmp = tmp->next)
12330- {
12331- CandlMatrix* srcmat;
12332- if (tmp->type == CANDL_RAW || tmp->type == CANDL_RAW_SCALPRIV
12333- || tmp->type == CANDL_WAW)
12334- srcmat = tmp->source->written;
12335- else
12336- srcmat = tmp->source->read;
12337- for (i = 0; i < cnt; ++i)
12338- if (allarrays[i] == CANDL_get_si(srcmat->p[tmp->ref_source][0]))
12339- break;
12340- if (i == cnt)
12341- allarrays[cnt++] = CANDL_get_si(srcmat->p[tmp->ref_source][0]);
12342- }
12343- allarrays[cnt] = -1;
12344+ nb_deps = cnt;
12345+ allarrays = (osl_relation_p*)malloc(sizeof(osl_relation_p)*cnt);
12346+
12347+ for (tmp = deps, cnt = 0; tmp; tmp = tmp->next) {
12348+ srcmat = candl_dependence_get_relation_ref_source_in_dep(tmp);
12349+ for (i = 0; i < cnt; ++i)
12350+ if (allarrays[i] == srcmat)
12351+ break;
12352+ if (i == cnt)
12353+ allarrays[cnt++] = srcmat;
12354+ }
12355+ allarrays[cnt] = NULL;
12356
12357 // 2- Iterate on all arrays.
12358- for (i = 0; allarrays[i] != -1; ++i)
12359- {
12360- // a- Collect all dependences to this array.
12361- CandlDependence* ardeps[nb_deps + 1];
12362- for (tmp = deps, cnt = 0; tmp; tmp = tmp->next)
12363- {
12364- CandlMatrix* srcmat;
12365- if (tmp->type == CANDL_RAW || tmp->type == CANDL_RAW_SCALPRIV
12366- || tmp->type == CANDL_WAW)
12367- srcmat = tmp->source->written;
12368- else
12369- srcmat = tmp->source->read;
12370- if (allarrays[i] == CANDL_get_si(srcmat->p[tmp->ref_source][0]))
12371- ardeps[cnt++] = tmp;
12372- }
12373- ardeps[cnt] = NULL;
12374-
12375- // b- First pruning. Remove all dependence polyhedra that are equal.
12376- for (j = 0; ardeps[j]; ++j)
12377- {
12378- for (k = j + 1; ardeps[k]; ++k)
12379- if (ardeps[j]->source == ardeps[k]->source &&
12380- ardeps[j]->target == ardeps[k]->target &&
12381- ardeps[j]->depth == ardeps[k]->depth &&
12382- candl_matrix_equal (ardeps[j]->domain, ardeps[k]->domain))
12383- {
12384- ardeps[k - 1]->next = ardeps[k+1];
12385- for (l = k; ardeps[l + 1]; ++l)
12386- ardeps[l] = ardeps[l + 1];
12387- ardeps[l] = NULL;
12388- --k;
12389- }
12390- }
12391-
12392- // c- Local pruning. Remove all self-dependences (1-cycles)
12393- // and all backward-dependences.
12394- for (j = 0; ardeps[j]; ++j)
12395- if (ardeps[j]->source >= ardeps[j]->target)
12396- {
12397- for (k = j; ardeps[k + 1]; ++k)
12398- ardeps[k] = ardeps[k + 1];
12399- ardeps[k] = NULL;
12400- --j;
12401- }
12402-
12403- // d- Local pruning. Remove all dependences where source/target
12404- // are not unimodular in the iterator part of the access function and
12405- // iteration domain.
12406- for (j = 0; ardeps[j]; ++j)
12407- if (! is_iter_unimodular (ardeps[j]))
12408- {
12409- for (k = j; ardeps[k + 1]; ++k)
12410- ardeps[k] = ardeps[k + 1];
12411- ardeps[k] = NULL;
12412- --j;
12413- }
12414-
12415- // d- Given a pair of statements, check if there is a dependence
12416- // path from its source to its target, of same type of a found
12417- // direct dependence.
12418- int stmts, stmtt;
12419- for (stmts = 0; stmts < nb_stmts - 2; ++stmts)
12420- for (stmtt = stmts + 2; stmtt < nb_stmts; ++stmtt)
12421- {
12422- // Ensure there exists a direct dependence between stmts
12423- // and stmtt.
12424- //printf ("consider S%d -> S%d\n", stmts, stmtt);
12425- for (j = 0; ardeps[j]; ++j)
12426- if (ardeps[j]->source->label == stmts &&
12427- ardeps[j]->target->label == stmtt)
12428- break;
12429- if (ardeps[j])
12430- {
12431- CandlStatement* source = ardeps[j]->source;
12432- CandlStatement* target = ardeps[j]->target;
12433-
12434- // Subset of deps that can be on the path.
12435- CandlDependence* curardeps[nb_deps + 1];
12436- for (k = 0, l = 0; ardeps[k]; ++k)
12437- if (ardeps[k]->source->label >= source->label &&
12438- ardeps[k]->source->label <= target->label &&
12439- ardeps[k]->target->label >= source->label &&
12440- ardeps[k]->target->label <= target->label)
12441- curardeps[l++] = ardeps[k];
12442- curardeps[l] = NULL;
12443- CandlDependence*** paths =
12444- find_dep_paths(curardeps, source, target);
12445-
12446- if (paths)
12447- {
12448- for (j = 0; ardeps[j]; ++j)
12449- if (ardeps[j]->source->label == stmts &&
12450- ardeps[j]->target->label == stmtt)
12451- {
12452- // Inspect all paths. If there is a path
12453- // that respect the transitive cover prop,
12454- // then discard the dependence.
12455- for (k = 0; paths[k] &&
12456- ! is_covering (ardeps[j], paths[k]); ++k)
12457- ;
12458- if (paths[k])
12459- {
12460- candl_matrix_free (ardeps[j]->domain);
12461- free (ardeps[j]);
12462- if (j == 0)
12463- deps = ardeps[j + 1];
12464- else
12465- ardeps[j - 1]->next = ardeps[j + 1];
12466- }
12467- }
12468- for (k = 0; paths[k]; ++k)
12469- free (paths[k]);
12470- free (paths);
12471- }
12472- }
12473- }
12474+ for (i = 0 ; allarrays[i] != NULL ; ++i) {
12475+ ardeps = (osl_dependence_p*) malloc(sizeof(osl_dependence_p) *
12476+ (nb_deps + 1));
12477+
12478+ // a- Collect all dependences to this array.
12479+ for (tmp = deps, cnt = 0; tmp; tmp = tmp->next) {
12480+ srcmat = candl_dependence_get_relation_ref_source_in_dep(tmp);
12481+ if (allarrays[i] == srcmat)
12482+ ardeps[cnt++] = tmp;
12483+ }
12484+ ardeps[cnt] = NULL;
12485+
12486+ // b- First pruning. Remove all dependence polyhedra that are equal.
12487+ for (j = 0; ardeps[j]; ++j)
12488+ for (k = j + 1; ardeps[k]; ++k)
12489+ if (ardeps[j]->source == ardeps[k]->source &&
12490+ ardeps[j]->target == ardeps[k]->target &&
12491+ ardeps[j]->depth == ardeps[k]->depth &&
12492+ osl_relation_equal(ardeps[j]->domain, ardeps[k]->domain)) {
12493+ ardeps[k - 1]->next = ardeps[k+1];
12494+ for (l = k; ardeps[l + 1]; ++l)
12495+ ardeps[l] = ardeps[l + 1];
12496+ ardeps[l] = NULL;
12497+ --k;
12498+ }
12499+
12500+ // c- Local pruning. Remove all self-dependences (1-cycles)
12501+ // and all backward-dependences.
12502+ for (j = 0; ardeps[j]; ++j) {
12503+ s_usr = ardeps[j]->source->usr;
12504+ t_usr = ardeps[j]->target->usr;
12505+ if (s_usr->label >= t_usr->label) {
12506+ for (k = j; ardeps[k + 1]; ++k)
12507+ ardeps[k] = ardeps[k + 1];
12508+ ardeps[k] = NULL;
12509+ --j;
12510+ }
12511 }
12512
12513+ // d- Local pruning. Remove all dependences where source/target
12514+ // are not unimodular in the iterator part of the access function and
12515+ // iteration domain.
12516+ for (j = 0; ardeps[j]; ++j)
12517+ if (! is_iter_unimodular(ardeps[j])) {
12518+ for (k = j; ardeps[k + 1]; ++k)
12519+ ardeps[k] = ardeps[k + 1];
12520+ ardeps[k] = NULL;
12521+ --j;
12522+ }
12523+
12524+ // d- Given a pair of statements, check if there is a dependence
12525+ // path from its source to its target, of same type of a found
12526+ // direct dependence.
12527+ int source_label, target_label;
12528+ for (source_label = 0; source_label < nb_stmts - 2; ++source_label)
12529+ for (target_label = source_label + 2; target_label < nb_stmts;
12530+ ++target_label) {
12531+ // Ensure there exists a direct dependence between source_label
12532+ // and target_label.
12533+ //printf ("consider S%d -> S%d\n", source_label, target_label);
12534+ for (j = 0; ardeps[j]; ++j) {
12535+ s_usr = ardeps[j]->source->usr;
12536+ t_usr = ardeps[j]->target->usr;
12537+ if (s_usr->label == source_label &&
12538+ t_usr->label == target_label)
12539+ break;
12540+ }
12541+ if (ardeps[j]) {
12542+ osl_statement_p source = ardeps[j]->source;
12543+ osl_statement_p target = ardeps[j]->target;
12544+
12545+ // Subset of deps that can be on the path.
12546+ curardeps = (osl_dependence_p*) malloc(sizeof(osl_dependence_p) *
12547+ (nb_deps + 1));
12548+
12549+ for (k = 0, l = 0; ardeps[k]; ++k) {
12550+ s_usr = ardeps[k]->source->usr;
12551+ t_usr = ardeps[k]->target->usr;
12552+ if (s_usr->label >= source->label &&
12553+ s_usr->label <= target->label &&
12554+ t_usr->label >= source->label &&
12555+ t_usr->label <= target->label)
12556+ curardeps[l++] = ardeps[k];
12557+ }
12558+ curardeps[l] = NULL;
12559+ paths = find_dep_paths(curardeps, source, target);
12560+
12561+ if (paths) {
12562+ for (j = 0; ardeps[j]; ++j) {
12563+ s_usr = ardeps[j]->source->usr;
12564+ t_usr = ardeps[j]->target->usr;
12565+ if (s_usr->label == source_label &&
12566+ t_usr->label == target_label) {
12567+ // Inspect all paths. If there is a path
12568+ // that respect the transitive cover prop,
12569+ // then discard the dependence.
12570+ for (k = 0; paths[k] && !is_covering(ardeps[j], paths[k]); ++k)
12571+ ;
12572+ if (paths[k]) {
12573+ osl_relation_free(ardeps[j]->domain);
12574+ free(ardeps[j]);
12575+ if (j == 0)
12576+ deps = ardeps[j + 1];
12577+ else
12578+ ardeps[j - 1]->next = ardeps[j + 1];
12579+ }
12580+ }
12581+ }
12582+ for (k = 0; paths[k]; ++k)
12583+ free(paths[k]);
12584+ free(paths);
12585+ }
12586+
12587+ free(curardeps);
12588+ }
12589+ }
12590+
12591+ free(ardeps);
12592+ }
12593+
12594+ free(allarrays);
12595+
12596 return deps;
12597 }
12598+
12599+#endif
12600diff --git a/source/scop.c b/source/scop.c
12601new file mode 100644
12602index 0000000..f6ec0ae
12603--- /dev/null
12604+++ b/source/scop.c
12605@@ -0,0 +1,93 @@
12606+
12607+
12608+ /**------ ( ----------------------------------------------------------**
12609+ ** )\ CAnDL **
12610+ **----- / ) --------------------------------------------------------**
12611+ ** ( * ( scop.c **
12612+ **---- \#/ --------------------------------------------------------**
12613+ ** .-"#'-. First version: june 7th 2012 **
12614+ **--- |"-.-"| -------------------------------------------------------**
12615+ | |
12616+ | |
12617+ ******** | | *************************************************************
12618+ * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
12619+ ******************************************************************************
12620+ * *
12621+ * Copyright (C) 2003-2008 Cedric Bastoul *
12622+ * *
12623+ * This is free software; you can redistribute it and/or modify it under the *
12624+ * terms of the GNU General Public License as published by the Free Software *
12625+ * Foundation; either version 2 of the License, or (at your option) any later *
12626+ * version. *
12627+ * *
12628+ * This software is distributed in the hope that it will be useful, but *
12629+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
12630+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
12631+ * for more details. *
12632+ * *
12633+ * You should have received a copy of the GNU General Public License along *
12634+ * with software; if not, write to the Free Software Foundation, Inc., *
12635+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
12636+ * *
12637+ * CAnDL, the Chunky Dependence Analyzer *
12638+ * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
12639+ * *
12640+ ******************************************************************************/
12641+
12642+/*
12643+ * author Joel Poudroux
12644+ */
12645+
12646+#include <stdlib.h>
12647+#include <osl/scop.h>
12648+#include <osl/statement.h>
12649+#include <candl/scop.h>
12650+#include <candl/statement.h>
12651+
12652+/**
12653+ * candl_scop_usr_init function:
12654+ * initialize a candl_scop_usr structure
12655+ *
12656+ * May, 2013 extended to each scop in the list,
12657+ */
12658+void candl_scop_usr_init(osl_scop_p scop) {
12659+
12660+ while (scop) {
12661+ candl_scop_usr_p scop_usr;
12662+
12663+ /* Init the scop_usr structure */
12664+ scop_usr = (candl_scop_usr_p) malloc(sizeof(candl_scop_usr_t));
12665+ scop_usr->scalars_privatizable = NULL;
12666+ scop_usr->usr_backup = scop->usr;
12667+ scop->usr = scop_usr;
12668+
12669+ candl_statement_usr_init_all(scop);
12670+
12671+ scop = scop->next;
12672+ }
12673+}
12674+
12675+
12676+/**
12677+ * candl_scop_usr_cleanup function:
12678+ */
12679+void candl_scop_usr_cleanup(osl_scop_p scop) {
12680+
12681+ while (scop) {
12682+ osl_statement_p statement = scop->statement;
12683+ candl_scop_usr_p scop_usr;
12684+ while (statement != NULL) {
12685+ candl_statement_usr_cleanup(statement);
12686+ statement = statement->next;
12687+ }
12688+ scop_usr = scop->usr;
12689+ if (scop_usr) {
12690+ if (scop_usr->scalars_privatizable)
12691+ free(scop_usr->scalars_privatizable);
12692+ scop->usr = scop_usr->usr_backup;
12693+ free(scop_usr);
12694+ }
12695+
12696+ scop = scop->next;
12697+ }
12698+}
12699diff --git a/source/statement.c b/source/statement.c
12700index 39ee0b8..d6845dd 100644
12701--- a/source/statement.c
12702+++ b/source/statement.c
12703@@ -1,18 +1,19 @@
12704
12705+
12706 /**------ ( ----------------------------------------------------------**
12707 ** )\ CAnDL **
12708 **----- / ) --------------------------------------------------------**
12709- ** ( * ( statement.c **
12710+ ** ( * ( usr.c **
12711 **---- \#/ --------------------------------------------------------**
12712- ** .-"#'-. First version: september 9th 2003 **
12713+ ** .-"#'-. First version: june 7th 2012 **
12714 **--- |"-.-"| -------------------------------------------------------**
12715- | |
12716- | |
12717+ | |
12718+ | |
12719 ******** | | *************************************************************
12720 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
12721 ******************************************************************************
12722 * *
12723- * Copyright (C) 2003 Cedric Bastoul *
12724+ * Copyright (C) 2003-2008 Cedric Bastoul *
12725 * *
12726 * This is free software; you can redistribute it and/or modify it under the *
12727 * terms of the GNU General Public License as published by the Free Software *
12728@@ -32,319 +33,103 @@
12729 * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
12730 * *
12731 ******************************************************************************/
12732-/* CAUTION: the english used for comments is probably the worst you ever read,
12733- * please feel free to correct and improve it !
12734- */
12735-
12736-# include <stdlib.h>
12737-# include <stdio.h>
12738-# include <ctype.h>
12739-# include <string.h>
12740-# include "../include/candl/candl.h"
12741
12742-
12743-/******************************************************************************
12744- * Structure display function *
12745- ******************************************************************************/
12746-
12747-
12748-/**
12749- * candl_statement_print_structure function:
12750- * Displays a CandlStatement structure (statement) into a file (file,
12751- * possibly stdout) in a way that trends to be understandable without falling
12752- * in a deep depression or, for the lucky ones, getting a headache... It
12753- * includes an indentation level (level) in order to work with others
12754- * print_structure functions.
12755- * - 18/09/2003: first version.
12756+/*
12757+ * author Joel Poudroux and Cedric Bastoul
12758 */
12759-void candl_statement_print_structure(file, statement, level)
12760-FILE * file ;
12761-CandlStatement * statement ;
12762-int level ;
12763-{ int i, j ;
12764-
12765- if (statement != NULL)
12766- { /* Go to the right level. */
12767- for(j=0; j<level; j++)
12768- fprintf(file,"|\t") ;
12769- fprintf(file,"+-- CandlStatement\n") ;
12770-
12771- /* A blank line. */
12772- for(j=0; j<=level+1; j++)
12773- fprintf(file,"|\t") ;
12774- fprintf(file,"\n") ;
12775-
12776- /* Go to the right level and print the label. */
12777- for(j=0; j<=level; j++)
12778- fprintf(file,"|\t") ;
12779- fprintf(file,"Label: %d\n",statement->label) ;
12780-
12781- /* A blank line. */
12782- for(j=0; j<=level+1; j++)
12783- fprintf(file,"|\t") ;
12784- fprintf(file,"\n") ;
12785-
12786- /* Go to the right level and print the type. */
12787- for(j=0; j<=level; j++)
12788- fprintf(file,"|\t") ;
12789- fprintf(file,"Type: ") ;
12790- switch (statement->type)
12791- { case CANDL_UNSET : fprintf(file,"UNSET\n") ; break ;
12792- case CANDL_ASSIGNMENT : fprintf(file,"assignment\n") ; break ;
12793- case CANDL_P_REDUCTION : fprintf(file,"plus-reduction\n") ; break ;
12794- case CANDL_M_REDUCTION : fprintf(file,"minus-reduction\n") ; break ;
12795- case CANDL_T_REDUCTION : fprintf(file,"times-reduction\n") ; break ;
12796- default : fprintf(file,"unknown\n") ;
12797- }
12798-
12799- /* A blank line. */
12800- for(j=0; j<=level+1; j++)
12801- fprintf(file,"|\t") ;
12802- fprintf(file,"\n") ;
12803-
12804- /* Go to the right level and print the outer loops. */
12805- for(j=0; j<=level; j++)
12806- fprintf(file,"|\t") ;
12807- fprintf(file,"Depth: %d, outer loops(s):",statement->depth) ;
12808- for (i=0;i<statement->depth;i++)
12809- fprintf(file," %d",statement->index[i]) ;
12810- fprintf(file,"\n") ;
12811-
12812- /* A blank line. */
12813- for(j=0; j<=level+1; j++)
12814- fprintf(file,"|\t") ;
12815- fprintf(file,"\n") ;
12816-
12817- /* Print the iteration domain. */
12818- candl_matrix_print_structure(file,statement->domain,level+1) ;
12819-
12820- /* Print the written data. */
12821- candl_matrix_print_structure(file,statement->written,level+1) ;
12822-
12823- /* Print the read data. */
12824- candl_matrix_print_structure(file,statement->read,level+1) ;
12825- }
12826- else
12827- { /* Go to the right level. */
12828- for(j=0; j<level; j++)
12829- fprintf(file,"|\t") ;
12830- fprintf(file,"+-- NULL statement\n") ;
12831- }
12832-
12833- /* The last line. */
12834- for(j=0; j<=level; j++)
12835- fprintf(file,"|\t") ;
12836- fprintf(file,"\n") ;
12837-}
12838-
12839-
12840-/**
12841- * candl_statement_print function:
12842- * This function prints the content of a CandlStatement structure (statement)
12843- * into a file (file, possibly stdout).
12844- * - 09/09/2003: first version.
12845- */
12846-void candl_statement_print(FILE * file, CandlStatement * statement)
12847-{ candl_statement_print_structure(file,statement,0) ;
12848-}
12849-
12850-
12851-/******************************************************************************
12852- * Memory deallocation function *
12853- ******************************************************************************/
12854-
12855-
12856-/**
12857- * candl_statement_free function:
12858- * This function frees the allocated memory for a CandlStatement structure.
12859- * - 09/09/2003: first version.
12860- */
12861-void candl_statement_free(CandlStatement * statement)
12862-{ free(statement->index) ;
12863- pip_matrix_free(statement->domain) ;
12864- pip_matrix_free(statement->read) ;
12865- pip_matrix_free(statement->written) ;
12866- free(statement) ;
12867-}
12868
12869+#include <stdlib.h>
12870+#include <osl/scop.h>
12871+#include <osl/statement.h>
12872+#include <osl/extensions/dependence.h>
12873+#include <osl/relation.h>
12874+#include <candl/macros.h>
12875+#include <candl/statement.h>
12876+#include <candl/util.h>
12877
12878-/******************************************************************************
12879- * Reading functions *
12880- ******************************************************************************/
12881+#define CANDL_STATEMENT_USR_INDEX_MAX_LOOP_DEPTH 128
12882
12883
12884 /**
12885- * candl_statement_read function:
12886- * This function reads statement data from a file (file) and puts them into
12887- * a CandlStatement structure. This function returns a pointer to this
12888- * structure.
12889- * - label is the statement number ;
12890- * - nb_parameters is the number of parameters.
12891- ***
12892- * - 09/09/2003: first version.
12893+ * candl_statement_usr_init_all function:
12894+ * Init each candl_statement_usr structure of statements
12895 */
12896-CandlStatement * candl_statement_read(FILE * file, int label, int nb_parameters)
12897-{ int i, n, * index ;
12898- char s[CANDL_MAX_STRING], str[CANDL_MAX_STRING], * c, type ;
12899- CandlStatement * statement ;
12900-
12901- /* Statement data. */
12902- statement = candl_statement_malloc() ;
12903-
12904- /* We first read the statement type. */
12905- while (fgets(s,CANDL_MAX_STRING,file) == 0) ;
12906- while ((*s=='#' || *s=='\n') || (sscanf(s," %c",&type)<1))
12907- fgets(s,CANDL_MAX_STRING,file) ;
12908+void candl_statement_usr_init_all(osl_scop_p scop) {
12909+
12910+ /* TODO
12911+ * that statements must be sorted to compute the statement label
12912+ * the problem is if the scop is reordered, the second transformed scop
12913+ * must be aligned with it
12914+ */
12915+
12916+ osl_statement_p iter;
12917+ osl_relation_p scattering;
12918+ candl_statement_usr_p stmt_usr;
12919+ int i, j, k;
12920+ int row;
12921+ int precision = scop->context->precision;
12922+ int count = 0; /* counter for statements */
12923
12924- switch (type)
12925- { case 'A': statement->type = CANDL_ASSIGNMENT ; break ;
12926- case 'P': statement->type = CANDL_P_REDUCTION ; break ;
12927- case 'M': statement->type = CANDL_M_REDUCTION ; break ;
12928- case 'T': statement->type = CANDL_T_REDUCTION ; break ;
12929- default : fprintf(stderr, "[Candl]ERROR: unknown statement type %c\n",type);
12930- fprintf(stderr, " possible types are:\n") ;
12931- fprintf(stderr, " - A for assignment (=),\n") ;
12932- fprintf(stderr, " - P for plus-reduction (+=),\n") ;
12933- fprintf(stderr, " - M for minus-reduction (-=),\n") ;
12934- fprintf(stderr, " - T for times-reduction (*=).\n") ;
12935- exit(1) ;
12936+ /* Initialize structures used in iterator indices computation. */
12937+ int val;
12938+ int max = 0;
12939+ int cur_index[CANDL_STATEMENT_USR_INDEX_MAX_LOOP_DEPTH];
12940+ int last[CANDL_STATEMENT_USR_INDEX_MAX_LOOP_DEPTH];
12941+ for (i = 0; i < CANDL_STATEMENT_USR_INDEX_MAX_LOOP_DEPTH; ++i) {
12942+ cur_index[i] = i;
12943+ last[i] = 0;
12944 }
12945-
12946- statement->label = label ;
12947- statement->domain = pip_matrix_read(file) ;
12948- statement->depth = statement->domain->NbColumns - nb_parameters - 2 ;
12949-
12950- index = (int *)malloc(sizeof(int)*statement->depth) ;
12951- if (index == NULL)
12952- { fprintf(stderr, "[Candl]ERROR: memory overflow.\n") ;
12953- exit(1) ;
12954- }
12955-
12956- do /* Skip the comments, spaces and empty lines... */
12957- { c = fgets(s,CANDL_MAX_STRING,file) ;
12958- while ((c != NULL) && isspace(*c) && (*c != '\n'))
12959- c++ ;
12960- }
12961- while (c != NULL && (*c == '#' || *c == '\n'));
12962+
12963+ /* Add useful information in the usr field of each statements */
12964+ for (iter = scop->statement ; iter != NULL ; iter = iter->next) {
12965+ scattering = iter->scattering;
12966
12967- if (c == NULL)
12968- { fprintf(stderr, "[Candl]ERROR: no labels in input file.\n") ;
12969- exit(1) ;
12970- }
12971- for (i=0;i<statement->depth;i++)
12972- { /* All iterator labels must be on the same line. */
12973- while (isspace(*c))
12974- c++ ;
12975- if (c == NULL || *c == '#' || *c == '\n')
12976- { fprintf(stderr, "[Candl]ERROR: not enough labels in input file.\n") ;
12977- exit(1) ;
12978- }
12979- /* n is strlen(str). */
12980- if (sscanf(c,"%s%n",str,&n) == 0)
12981- { fprintf(stderr, "[Candl]ERROR: no labels in input file.\n") ;
12982- exit(1) ;
12983+ stmt_usr = (candl_statement_usr_p) malloc(sizeof(candl_statement_usr_t));
12984+ stmt_usr->depth = scattering->nb_output_dims/2;
12985+ stmt_usr->label = count;
12986+ stmt_usr->type = OSL_DEPENDENCE_ASSIGNMENT;
12987+ stmt_usr->usr_backup = iter->usr;
12988+ stmt_usr->index = (stmt_usr->depth ?
12989+ (int*) malloc(stmt_usr->depth * sizeof(int)) :
12990+ NULL);
12991+
12992+ /* Compute the value of the iterator indices.
12993+ * extracted from the last candl
12994+ */
12995+ for (j = 0; j < stmt_usr->depth; ++j) {
12996+ row = candl_util_relation_get_line(scattering, j*2);
12997+ val = osl_int_get_si(precision,
12998+ scattering->m[row][scattering->nb_columns - 1]);
12999+ if (last[j] < val) {
13000+ last[j] = val;
13001+ for (k = j + 1; k < CANDL_STATEMENT_USR_INDEX_MAX_LOOP_DEPTH; ++k)
13002+ last[k] = 0;
13003+ for (k = j; k < CANDL_STATEMENT_USR_INDEX_MAX_LOOP_DEPTH; ++k)
13004+ cur_index[k] = max + (k - j) + 1;
13005+ break;
13006+ }
13007 }
13008- sscanf(str,"%d",&index[i]) ;
13009- c += n ;
13010- }
13011- statement->index = index ;
13012-
13013- statement->written = pip_matrix_read(file) ;
13014- statement->read = pip_matrix_read(file) ;
13015+ for (j = 0; j < stmt_usr->depth; ++j)
13016+ stmt_usr->index[j] = cur_index[j];
13017
13018- return statement ;
13019-}
13020-
13021-
13022-/******************************************************************************
13023- * Processing functions *
13024- ******************************************************************************/
13025-
13026-
13027-/**
13028- * candl_statement_malloc function:
13029- * This function allocates the memory space for a CandlStatement structure and
13030- * sets its fields with default values. Then it returns a pointer to the
13031- * allocated space.
13032- * - 09/12/2005: first version.
13033- */
13034-CandlStatement * candl_statement_malloc()
13035-{ CandlStatement * statement ;
13036-
13037- /* Memory allocation for the CloogProgram structure. */
13038- statement = (CandlStatement *)malloc(sizeof(CandlStatement)) ;
13039- if (statement == NULL)
13040- { fprintf(stderr, "[Candl]ERROR: memory overflow.\n") ;
13041- exit(1) ;
13042+ max = max < cur_index[j - 1] ? cur_index[j - 1] : max;
13043+
13044+ iter->usr = stmt_usr;
13045+ count++;
13046 }
13047-
13048- /* We set the various fields with default values. */
13049- statement->label = CANDL_UNSET ;
13050- statement->type = CANDL_UNSET ;
13051- statement->depth = CANDL_UNSET ;
13052- statement->index = NULL ;
13053- statement->domain = NULL ;
13054- statement->written = NULL ;
13055- statement->read = NULL ;
13056- statement->ref = NULL ;
13057-
13058- return statement ;
13059 }
13060
13061
13062 /**
13063- * candl_statement_commute function:
13064- * This function returns 1 if the two statements given as parameter commute,
13065- * 0 otherwise. It uses the statement type information to answer the question.
13066- * - 09/12/2005: first version.
13067+ * candl_usr_free function:
13068 */
13069-int candl_statement_commute(statement1, statement2)
13070-CandlStatement * statement1, * statement2 ;
13071-{ int type1, type2, nb_rows, i ;
13072-
13073- type1 = statement1->type ;
13074- type2 = statement2->type ;
13075-
13076- /* In the case of self-dependence, a statement commutes with hitself if
13077- * it is a reduction.
13078- */
13079- if ((statement1 == statement2) &&
13080- ((type1 == CANDL_P_REDUCTION) ||
13081- (type1 == CANDL_M_REDUCTION) ||
13082- (type1 == CANDL_T_REDUCTION)))
13083- return 1 ;
13084-
13085- /* Two statement commute when they are a reduction of the same type (or if
13086- * their left and right members are the same, but it's not exploited here).
13087- * The type may differ if it is either minus or plus-reduction. Furthermore,
13088- * they have to write onto the same array (and only one array).
13089- */
13090- if (((type1 == CANDL_P_REDUCTION) && (type2 == CANDL_P_REDUCTION)) ||
13091- ((type1 == CANDL_M_REDUCTION) && (type2 == CANDL_M_REDUCTION)) ||
13092- ((type1 == CANDL_T_REDUCTION) && (type2 == CANDL_T_REDUCTION)) ||
13093- ((type1 == CANDL_P_REDUCTION) && (type2 == CANDL_M_REDUCTION)) ||
13094- ((type1 == CANDL_M_REDUCTION) && (type2 == CANDL_P_REDUCTION)))
13095- { /* Here we check that there is one, only one and the same array. */
13096- nb_rows = statement1->written->NbRows ;
13097- if ((nb_rows == 0) || (nb_rows != statement2->written->NbRows))
13098- return 0 ;
13099-
13100- if (statement1->written->p[0][0] != statement2->written->p[0][0])
13101- return 0 ;
13102-
13103- for (i=1;i<nb_rows;i++)
13104- if ((statement1->written->p[i][0] != 0) ||
13105- (statement2->written->p[i][0] != 0))
13106- return 0 ;
13107-
13108- return 1 ;
13109- }
13110-
13111- return 0 ;
13112+void candl_statement_usr_cleanup(osl_statement_p statement) {
13113+ candl_statement_usr_p stmt_usr;
13114+ stmt_usr = statement->usr;
13115+ if (stmt_usr) {
13116+ if (stmt_usr->index)
13117+ free(stmt_usr->index);
13118+ statement->usr = stmt_usr->usr_backup;
13119+ free(stmt_usr);
13120+ }
13121 }
13122-
13123-
13124-
13125-
13126-
13127-
13128diff --git a/source/util.c b/source/util.c
13129new file mode 100644
13130index 0000000..df83aad
13131--- /dev/null
13132+++ b/source/util.c
13133@@ -0,0 +1,207 @@
13134+
13135+ /**------ ( ----------------------------------------------------------**
13136+ ** )\ CAnDL **
13137+ **----- / ) --------------------------------------------------------**
13138+ ** ( * ( util.c **
13139+ **---- \#/ --------------------------------------------------------**
13140+ ** .-"#'-. First version: june 7th 2012 **
13141+ **--- |"-.-"| -------------------------------------------------------**
13142+ | |
13143+ | |
13144+ ******** | | *************************************************************
13145+ * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
13146+ ******************************************************************************
13147+ * *
13148+ * Copyright (C) 2003-2008 Cedric Bastoul *
13149+ * *
13150+ * This is free software; you can redistribute it and/or modify it under the *
13151+ * terms of the GNU General Public License as published by the Free Software *
13152+ * Foundation; either version 2 of the License, or (at your option) any later *
13153+ * version. *
13154+ * *
13155+ * This software is distributed in the hope that it will be useful, but *
13156+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
13157+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
13158+ * for more details. *
13159+ * *
13160+ * You should have received a copy of the GNU General Public License along *
13161+ * with software; if not, write to the Free Software Foundation, Inc., *
13162+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
13163+ * *
13164+ * CAnDL, the Chunky Dependence Analyzer *
13165+ * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
13166+ * *
13167+ ******************************************************************************/
13168+
13169+/*
13170+ * author Joel Poudroux and Cedric Bastoul
13171+ */
13172+
13173+#include <stdio.h>
13174+#include <stdlib.h>
13175+#include <osl/statement.h>
13176+#include <osl/relation.h>
13177+#include <osl/macros.h>
13178+#include <osl/extensions/dependence.h>
13179+#include <osl/relation_list.h>
13180+#include <osl/scop.h>
13181+#include <candl/macros.h>
13182+#include <candl/util.h>
13183+#include <candl/statement.h>
13184+
13185+
13186+/**
13187+ * candl_util_relation_get_line function:
13188+ * Because the lines in the scattering matrix may have not ordered, we have to
13189+ * search the corresponding line. It returns the first line where the value is
13190+ * different from zero in the `column'. `column' is between 0 and
13191+ * nb_output_dims-1
13192+ * \param[in] relation
13193+ * \param[in] column Line to search
13194+ * \return Return the real line
13195+ */
13196+int candl_util_relation_get_line(osl_relation_p relation, int column) {
13197+ if (column < 0 || column > relation->nb_output_dims)
13198+ return -1;
13199+ int i;
13200+ int precision = relation->precision;
13201+ for (i = 0 ; i < relation->nb_rows ; i++) {
13202+ if (!osl_int_zero(precision, relation->m[i][column + 1])) {
13203+ break;
13204+ }
13205+ }
13206+ return (i == relation->nb_rows ? -1 : i );
13207+}
13208+
13209+
13210+
13211+/* Check if two scop can be compared (same number of statements and
13212+ * same access array/domain in the same order)
13213+ *
13214+ * \param[in] s1 first scop to compare
13215+ * \param[in] s2 second scop to compare
13216+ * \return 1 if two scops equal, 0 otherwise
13217+ */
13218+int candl_util_check_scop(osl_scop_p s1, osl_scop_p s2) {
13219+
13220+ osl_statement_p it1 = s1->statement, it2 = s2->statement;
13221+ for (; it1 != NULL && it2 != NULL ; it1 = it1->next, it2 = it2->next) {
13222+ if (!osl_relation_list_equal(it1->access, it2->access))
13223+ return 0;
13224+ if (!osl_relation_equal(it1->domain, it2->domain))
13225+ return 0;
13226+ }
13227+
13228+ /* Different number of statements */
13229+ if ((it1 == NULL || it2 == NULL) && it1 != it2)
13230+ return 0;
13231+
13232+ return 1;
13233+}
13234+
13235+/* Extends the candl_util_check_scop() functionality to a list of scops
13236+ * Compares each scop in s1 to the corresponding element in list s2
13237+ * same access array/domain in the same order)
13238+ *
13239+ * \param[in] s1 first scop List to compare
13240+ * \param[in] s2 second scop List to compare
13241+ * \return 1 if two scops lists equal, 0 otherwise
13242+ */
13243+int candl_util_check_scop_list(osl_scop_p s1, osl_scop_p s2) {
13244+
13245+ while ((s1!=NULL) && (s2!=NULL)) {
13246+ if(!candl_util_check_scop(s1, s2))
13247+ return 0;
13248+
13249+ s1 = s1->next;
13250+ s2 = s2->next;
13251+ }
13252+
13253+ /* Different number of scops */
13254+ if ((s1 == NULL || s2 == NULL) && s1 != s2)
13255+ return 0;
13256+
13257+ /*scop lists can be compared*/
13258+ return 1;
13259+}
13260+
13261+/* Return the number access array which have the type `type'
13262+ */
13263+static int count_nb_access(osl_statement_p st, int type) {
13264+ osl_relation_list_p access = st->access;
13265+ int count = 0;
13266+ for (; access != NULL ; access = access->next)
13267+ if (access->elt->type == type)
13268+ count ++;
13269+ return count;
13270+}
13271+
13272+
13273+/**
13274+ * candl_util_statement_commute function:
13275+ * This function returns 1 if the two statements given as parameter commute,
13276+ * 0 otherwise. It uses the statement type information to answer the question.
13277+ * - 09/12/2005: first version.
13278+ */
13279+int candl_util_statement_commute(osl_statement_p statement1,
13280+ osl_statement_p statement2) {
13281+ candl_statement_usr_p usr1, usr2;
13282+ int type1, type2;
13283+ int id1, id2;
13284+
13285+ usr1 = statement1->usr;
13286+ usr2 = statement2->usr;
13287+ type1 = usr1->type;
13288+ type2 = usr2->type;
13289+
13290+ /* In the case of self-dependence, a statement commutes with hitself if
13291+ * it is a reduction.
13292+ */
13293+ if ((statement1 == statement2) &&
13294+ ((type1 == OSL_DEPENDENCE_P_REDUCTION) ||
13295+ (type1 == OSL_DEPENDENCE_M_REDUCTION) ||
13296+ (type1 == OSL_DEPENDENCE_T_REDUCTION)))
13297+ return 1;
13298+
13299+ /* Two statement commute when they are a reduction of the same type (or if
13300+ * their left and right members are the same, but it's not exploited here).
13301+ * The type may differ if it is either minus or plus-reduction. Furthermore,
13302+ * they have to write onto the same array (and only one array).
13303+ */
13304+ if ((type1 == OSL_DEPENDENCE_P_REDUCTION && type2 == OSL_DEPENDENCE_P_REDUCTION) ||
13305+ (type1 == OSL_DEPENDENCE_M_REDUCTION && type2 == OSL_DEPENDENCE_M_REDUCTION) ||
13306+ (type1 == OSL_DEPENDENCE_T_REDUCTION && type2 == OSL_DEPENDENCE_T_REDUCTION) ||
13307+ (type1 == OSL_DEPENDENCE_P_REDUCTION && type2 == OSL_DEPENDENCE_M_REDUCTION) ||
13308+ (type1 == OSL_DEPENDENCE_M_REDUCTION && type2 == OSL_DEPENDENCE_P_REDUCTION)) {
13309+ /* Here we check that there is one, only one and the same array. */
13310+ if (count_nb_access(statement1, OSL_TYPE_WRITE) > 1 ||
13311+ count_nb_access(statement2, OSL_TYPE_WRITE) > 1)
13312+ return 0;
13313+
13314+ /* search the first osl_write access */
13315+ osl_relation_list_p access1 = statement1->access;
13316+ osl_relation_list_p access2 = statement2->access;
13317+ for (; access1 != NULL && access2 != NULL ;
13318+ access1 = access1->next, access2 = access2->next)
13319+ if (access1->elt->type == OSL_TYPE_WRITE)
13320+ break;
13321+
13322+ if (access1 == NULL || access2 == NULL ||
13323+ access2->elt->type != OSL_TYPE_WRITE ||
13324+ access2->elt->nb_output_dims != access1->elt->nb_output_dims) {
13325+ osl_statement_dump(stderr, statement1);
13326+ osl_statement_dump(stderr, statement2);
13327+ CANDL_error("These statements haven't the same access array or access is NULL");
13328+ }
13329+
13330+ /* Check if the first dim (the Arr column) is the same */
13331+ id1 = osl_relation_get_array_id(access1->elt);
13332+ id2 = osl_relation_get_array_id(access2->elt);
13333+ if (id1 != id2)
13334+ return 0;
13335+
13336+ return 1;
13337+ }
13338+
13339+ return 0;
13340+}
13341diff --git a/source/violation.c b/source/violation.c
13342index 1f2d4bb..3f8e3fe 100644
13343--- a/source/violation.c
13344+++ b/source/violation.c
13345@@ -6,8 +6,8 @@
13346 **---- \#/ --------------------------------------------------------**
13347 ** .-"#'-. First version: december 12th 2005 **
13348 **--- |"-.-"| -------------------------------------------------------**
13349- | |
13350- | |
13351+ | |
13352+ | |
13353 ******** | | *************************************************************
13354 * CAnDL '-._,-' the Chunky Analyzer for Dependences in Loops (experimental) *
13355 ******************************************************************************
13356@@ -36,10 +36,20 @@
13357 * please feel free to correct and improve it !
13358 */
13359
13360-# include <stdlib.h>
13361-# include <stdio.h>
13362-# include <string.h>
13363-# include "../include/candl/candl.h"
13364+#include <stdlib.h>
13365+#include <stdio.h>
13366+#include <string.h>
13367+#include <osl/macros.h>
13368+#include <osl/relation.h>
13369+#include <osl/statement.h>
13370+#include <osl/scop.h>
13371+#include <osl/extensions/dependence.h>
13372+#include <candl/macros.h>
13373+#include <candl/matrix.h>
13374+#include <candl/piplib.h>
13375+#include <candl/piplib-wrapper.h>
13376+#include <candl/statement.h>
13377+#include <candl/violation.h>
13378
13379
13380 /******************************************************************************
13381@@ -48,84 +58,79 @@
13382
13383
13384 /**
13385- * candl_violation_print_structure function:
13386+ * candl_violation_idump function:
13387 * Displays a CandlViolation structure (violation) into a file (file,
13388 * possibly stdout) in a way that trends to be understandable without falling
13389 * in a deep depression or, for the lucky ones, getting a headache... It
13390 * includes an indentation level (level) in order to work with others
13391- * print_structure functions.
13392+ * idump functions.
13393 * - 18/09/2003: first version.
13394 */
13395-void candl_violation_print_structure(file, violation, level)
13396-FILE * file ;
13397-CandlViolation * violation ;
13398-int level ;
13399-{ int j, first=1 ;
13400- CandlDependence * next=NULL ;
13401-
13402- if (violation != NULL)
13403- { /* Go to the right level. */
13404+void candl_violation_idump(FILE *file, candl_violation_p violation,
13405+ int level) {
13406+ int j, first=1;
13407+ osl_dependence_p next=NULL;
13408+
13409+ if (violation != NULL) { /* Go to the right level. */
13410 for(j=0; j<level; j++)
13411- fprintf(file,"|\t") ;
13412- fprintf(file,"+-- CandlViolation\n") ;
13413- }
13414- else
13415- { for(j=0; j<level; j++)
13416- fprintf(file,"|\t") ;
13417- fprintf(file,"+-- NULL dependence violation\n") ;
13418+ fprintf(file,"|\t");
13419+ fprintf(file,"+-- CandlViolation\n");
13420+ } else {
13421+ for(j=0; j<level; j++)
13422+ fprintf(file,"|\t");
13423+ fprintf(file,"+-- NULL dependence violation\n");
13424 }
13425
13426- while (violation != NULL)
13427- { if (!first)
13428- { /* Go to the right level. */
13429+ while (violation != NULL) {
13430+ if (!first) { /* Go to the right level. */
13431 for(j=0; j<level; j++)
13432- fprintf(file,"|\t") ;
13433- fprintf(file,"| CandlViolation\n") ;
13434+ fprintf(file,"|\t");
13435+ fprintf(file,"| CandlViolation\n");
13436+ } else {
13437+ first = 0;
13438 }
13439- else
13440- first = 0 ;
13441
13442 /* A blank line. */
13443 for(j=0; j<=level+1; j++)
13444- fprintf(file,"|\t") ;
13445- fprintf(file,"\n") ;
13446+ fprintf(file,"|\t");
13447+ fprintf(file,"\n");
13448
13449 /* Go to the right level and print the dimension. */
13450 for(j=0; j<=level; j++)
13451- fprintf(file,"|\t") ;
13452- fprintf(file,"Dimension: %d\n",violation->dimension) ;
13453+ fprintf(file,"|\t");
13454+ fprintf(file,"Dimension: %d\n",violation->dimension);
13455
13456 /* A blank line. */
13457 for(j=0; j<=level+1; j++)
13458- fprintf(file,"|\t") ;
13459- fprintf(file,"\n") ;
13460+ fprintf(file,"|\t");
13461+ fprintf(file,"\n");
13462
13463 /* Print the dependence. */
13464- if (violation->dependence != NULL)
13465- { next = violation->dependence->next ; /* To not print the whole list... */
13466- violation->dependence->next = NULL ; /* I know it's not beautiful :-/ ! */
13467+ if (violation->dependence != NULL) {
13468+ next = violation->dependence->next; /* To not print the whole list... */
13469+ violation->dependence->next = NULL; /* I know it's not beautiful :-/ ! */
13470 }
13471- candl_dependence_print_structure(file,violation->dependence,level+1) ;
13472+ osl_dependence_idump(file,violation->dependence,level+1);
13473 if (violation->dependence != NULL)
13474- violation->dependence->next = next ;
13475+ violation->dependence->next = next;
13476
13477 /* Print the dependence polyhedron. */
13478- candl_matrix_print_structure(file,violation->domain,level+1) ;
13479+ osl_relation_idump(file, violation->domain, level+1);
13480
13481- violation = violation->next ;
13482+ violation = violation->next;
13483
13484 /* Next line. */
13485- if (violation != NULL)
13486- { for (j=0; j<=level; j++)
13487- fprintf(file,"|\t") ;
13488- fprintf(file,"V\n") ;
13489+ if (violation != NULL) {
13490+ for (j=0; j<=level; j++)
13491+ fprintf(file,"|\t");
13492+ fprintf(file,"V\n");
13493 }
13494 }
13495
13496 /* The last line. */
13497 for(j=0; j<=level; j++)
13498- fprintf(file,"|\t") ;
13499- fprintf(file,"\n") ;
13500+ fprintf(file,"|\t");
13501+ fprintf(file,"\n");
13502 }
13503
13504
13505@@ -133,8 +138,8 @@ int level ;
13506 * This function prints the content of a CandlViolation structure
13507 * (violation) into a file (file, possibly stdout).
13508 */
13509-void candl_violation_print(FILE * file, CandlViolation * violation)
13510-{ candl_violation_print_structure(file,violation,0) ;
13511+void candl_violation_dump(FILE * file, candl_violation_p violation) {
13512+ candl_violation_idump(file,violation,0);
13513 }
13514
13515
13516@@ -144,43 +149,47 @@ void candl_violation_print(FILE * file, CandlViolation * violation)
13517 * See http://www.graphviz.org
13518 * - 12/12/2005: first version.
13519 */
13520-void candl_violation_pprint(FILE * file, CandlViolation * violation)
13521-{ int i=0 ;
13522- CandlDependence * dependence ;
13523+void candl_violation_pprint(FILE * file, candl_violation_p violation) {
13524+ int i=0;
13525+ osl_dependence_p dependence;
13526+ candl_statement_usr_p s_usr;
13527+ candl_statement_usr_p t_usr;
13528
13529- fprintf(file,"digraph G {\n") ;
13530+ fprintf(file,"digraph G {\n");
13531
13532- fprintf(file,"# Legality Violation Graph\n") ;
13533+ fprintf(file,"# Legality Violation Graph\n");
13534 fprintf(file,"# Generated by Candl "CANDL_RELEASE" "CANDL_VERSION" bits\n");
13535 if (violation == NULL)
13536- fprintf(file,"# Congratulations: the transformation is legal !\n");
13537-
13538- while (violation != NULL)
13539- { dependence = violation->dependence ;
13540-
13541- fprintf(file," S%d -> S%d [label=\" ",dependence->source->label,
13542- dependence->target->label) ;
13543- switch (dependence->type)
13544- { case CANDL_UNSET : fprintf(file,"UNSET") ; break ;
13545- case CANDL_RAW : fprintf(file,"RAW") ; break ;
13546- case CANDL_WAR : fprintf(file,"WAR") ; break ;
13547- case CANDL_WAW : fprintf(file,"WAW") ; break ;
13548- case CANDL_RAR : fprintf(file,"RAR") ; break ;
13549- default : fprintf(file,"unknown") ;
13550+ fprintf(file,"# Congratulations: the transformation is legal !\n");
13551+
13552+ while (violation != NULL) {
13553+ dependence = violation->dependence;
13554+ s_usr = dependence->stmt_source_ptr->usr;
13555+ t_usr = dependence->stmt_target_ptr->usr;
13556+
13557+ fprintf(file," S%d -> S%d [label=\" ", s_usr->label,
13558+ t_usr->label);
13559+ switch (dependence->type) {
13560+ case OSL_UNDEFINED : fprintf(file,"UNSET"); break;
13561+ case OSL_DEPENDENCE_RAW : fprintf(file,"RAW") ; break;
13562+ case OSL_DEPENDENCE_WAR : fprintf(file,"WAR") ; break;
13563+ case OSL_DEPENDENCE_WAW : fprintf(file,"WAW") ; break;
13564+ case OSL_DEPENDENCE_RAR : fprintf(file,"RAR") ; break;
13565+ default : fprintf(file,"unknown");
13566 }
13567 fprintf(file," depth %d, ref %d->%d, viol %d \"];\n",
13568 dependence->depth,
13569 dependence->ref_source,
13570 dependence->ref_target,
13571- violation->dimension) ;
13572- violation = violation->next ;
13573- i++ ;
13574+ violation->dimension);
13575+ violation = violation->next;
13576+ i++;
13577 }
13578
13579 if (i>4)
13580- fprintf(file,"# Number of edges = %i\n}\n",i) ;
13581+ fprintf(file,"# Number of edges = %i\n}\n",i);
13582 else
13583- fprintf(file,"}\n") ;
13584+ fprintf(file,"}\n");
13585 }
13586
13587
13588@@ -190,13 +199,14 @@ void candl_violation_pprint(FILE * file, CandlViolation * violation)
13589 * violation graph.
13590 * - 20/03/2006: first version.
13591 */
13592-void candl_violation_view(CandlViolation * violation)
13593-{ FILE * temp_output ;
13594-
13595- temp_output = fopen(CANDL_TEMP_OUTPUT,"w") ;
13596- candl_violation_pprint(temp_output,violation) ;
13597- fclose(temp_output) ;
13598- system("(dot -Tps "CANDL_TEMP_OUTPUT" | gv - &) && rm -f "CANDL_TEMP_OUTPUT) ;
13599+void candl_violation_view(candl_violation_p violation) {
13600+ FILE * temp_output;
13601+ temp_output = fopen(CANDL_TEMP_OUTPUT,"w+");
13602+ candl_violation_pprint(temp_output,violation);
13603+ fclose(temp_output);
13604+ /* check the return to remove the warning compilation */
13605+ if(system("dot -Tps "CANDL_TEMP_OUTPUT" | gv - && rm -f "CANDL_TEMP_OUTPUT" &"))
13606+ ;
13607 }
13608
13609
13610@@ -208,14 +218,13 @@ void candl_violation_view(CandlViolation * violation)
13611 * This function frees the allocated memory for a CandlViolation structure.
13612 * - 18/09/2003: first version.
13613 */
13614-void candl_violation_free(CandlViolation * violation)
13615-{ CandlViolation * next ;
13616-
13617- while (violation != NULL)
13618- { next = violation->next ;
13619- candl_matrix_free(violation->domain) ;
13620- free(violation) ;
13621- violation = next ;
13622+void candl_violation_free(candl_violation_p violation) {
13623+ candl_violation_p next;
13624+ while (violation != NULL) {
13625+ next = violation->next;
13626+ osl_relation_free(violation->domain);
13627+ free(violation);
13628+ violation = next;
13629 }
13630 }
13631
13632@@ -232,23 +241,27 @@ void candl_violation_free(CandlViolation * violation)
13633 * allocated space.
13634 * - 07/12/2005: first version.
13635 */
13636-CandlViolation * candl_violation_malloc()
13637-{ CandlViolation * violation ;
13638+candl_violation_p candl_violation_malloc() {
13639+ candl_violation_p violation;
13640
13641 /* Memory allocation for the CandlViolation structure. */
13642- violation = (CandlViolation *)malloc(sizeof(CandlViolation)) ;
13643- if (violation == NULL)
13644- { fprintf(stderr, "[Candl]ERROR: memory overflow.\n") ;
13645- exit(1) ;
13646+ violation = (candl_violation_p) malloc(sizeof(candl_violation_t));
13647+ if (violation == NULL) {
13648+ fprintf(stderr, "[Candl]ERROR: memory overflow.\n");
13649+ exit(1);
13650 }
13651
13652 /* We set the various fields with default values. */
13653- violation->dependence = NULL ;
13654- violation->domain = NULL ;
13655- violation->next = NULL ;
13656- violation->dimension = CANDL_UNSET ;
13657-
13658- return violation ;
13659+ violation->dependence = NULL;
13660+ violation->domain = NULL;
13661+ violation->next = NULL;
13662+ violation->dimension = OSL_UNDEFINED;
13663+ violation->source_nb_output_dims_scattering = -1;
13664+ violation->target_nb_output_dims_scattering = -1;
13665+ violation->source_nb_local_dims_scattering = -1;
13666+ violation->target_nb_local_dims_scattering = -1;
13667+
13668+ return violation;
13669 }
13670
13671
13672@@ -258,22 +271,23 @@ CandlViolation * candl_violation_malloc()
13673 * of this list is (start). This function updates (now) to the end of the loop
13674 * list (loop), and updates (start) if the added element is the first one -that
13675 * is when (start) is NULL-.
13676- * - 12/12/2005: first version (from candl_dependence_add).
13677+ * - 12/12/2005: first version (from candl_dependence_add,
13678+ * currently osl_dependence_add).
13679 */
13680-void candl_violation_add(start, now, violation)
13681-CandlViolation ** start, ** now, * violation ;
13682-{ if (violation != NULL)
13683- { if (*start == NULL)
13684- { *start = violation ;
13685- *now = *start ;
13686- }
13687- else
13688- { (*now)->next = violation ;
13689- *now = (*now)->next ;
13690+void candl_violation_add(candl_violation_p* start,
13691+ candl_violation_p* now,
13692+ candl_violation_p violation) {
13693+ if (violation != NULL) {
13694+ if (*start == NULL) {
13695+ *start = violation;
13696+ *now = *start;
13697+ } else {
13698+ (*now)->next = violation;
13699+ *now = (*now)->next;
13700 }
13701
13702 while ((*now)->next != NULL)
13703- *now = (*now)->next ;
13704+ *now = (*now)->next;
13705 }
13706 }
13707
13708@@ -289,86 +303,97 @@ CandlViolation ** start, ** now, * violation ;
13709 **
13710 * - 12/12/2005: first version.
13711 */
13712-CandlViolation * candl_violation(program, dependence, options)
13713-CandlProgram * program ;
13714-CandlDependence * dependence ;
13715-CandlOptions * options ;
13716-{ int dimension, max_dimension, violated ;
13717- CandlMatrix * system, * domain, * t_source, * t_target ;
13718- CandlStatement * source, * target ;
13719- CandlViolation * violation=NULL, * now=NULL, * new ;
13720- PipOptions * pip_options ;
13721- PipQuast * solution ;
13722-
13723- /* If there is no program or transformation, we consider this legal. */
13724- if ((program == NULL) || (program->transformation == NULL))
13725- return NULL ;
13726-
13727- /* If the dependence graph is not already built, do it. */
13728- if (dependence == NULL)
13729- dependence = candl_dependence(program,options) ;
13730-
13731- pip_options = pip_options_init() ;
13732- pip_options->Simplify = 1 ;
13733+candl_violation_p candl_violation(osl_scop_p orig_scop,
13734+ osl_dependence_p orig_dependence,
13735+ osl_scop_p test_scop,
13736+ candl_options_p options) {
13737+ osl_statement_p source, target, iter;
13738+ osl_statement_p *stmts;
13739+ osl_relation_p t_source, t_target;
13740+ candl_statement_usr_p s_usr, t_usr;
13741+ candl_violation_p violation = NULL, now, new;
13742+ PipOptions *pip_options;
13743+ PipQuast *solution;
13744+ int i;
13745+ int nb_par = orig_scop->context->nb_parameters;
13746+ int nb_stmts = 0;
13747+ int dimension, max_dimension, violated;
13748+
13749+ /* If there is no scop or transformation, we consider this legal. */
13750+ if (test_scop == NULL)
13751+ return NULL;
13752+
13753+ /* Temporary array to access faster at the `label'th statement */
13754+ for (iter = test_scop->statement ; iter != NULL ;
13755+ iter = iter->next, nb_stmts++)
13756+ ;
13757+ stmts = (osl_statement_p*) malloc(sizeof(osl_statement_p) * nb_stmts);
13758+ for (i = 0, iter = test_scop->statement ; iter != NULL ;
13759+ iter = iter->next, i++) {
13760+ stmts[i] = iter;
13761+ }
13762
13763+ pip_options = pip_options_init();
13764+ pip_options->Simplify = 1;
13765+
13766 /* We check every edge of the dependence graph. */
13767- while (dependence != NULL)
13768- { source = dependence->source ;
13769- target = dependence->target ;
13770- domain = dependence->domain ;
13771+ while (orig_dependence != NULL) {
13772+ source = orig_dependence->stmt_source_ptr;
13773+ target = orig_dependence->stmt_target_ptr;
13774+ s_usr = source->usr;
13775+ t_usr = target->usr;
13776
13777 /* We find the source transformation matrix. */
13778- t_source = program->transformation[source->label] ;
13779+ t_source = stmts[s_usr->label]->scattering;
13780
13781 /* We find the target transformation matrix. */
13782- t_target = program->transformation[target->label] ;
13783-
13784+ t_target = stmts[t_usr->label]->scattering;
13785+
13786 /* The maximal dimension we have to check for legality. */
13787- max_dimension = CANDL_min(t_source->NbRows,t_target->NbRows) ;
13788-
13789+ max_dimension = CANDL_min(t_source->nb_output_dims,t_target->nb_output_dims);
13790+
13791 /* We check each dimension for legality. */
13792- for (dimension = 0; dimension<max_dimension; dimension++)
13793- { violated = 0 ;
13794- system = NULL ;
13795+ for (dimension = 1; dimension <= max_dimension; dimension++) {
13796+ violated = 0;
13797
13798 /* We build the constraint system corresponding to that
13799 * violation then check if there is an integral point inside,
13800 * if yes there is actually a dependence violation and we
13801 * will add this one to the list.
13802 */
13803- system = candl_matrix_violation(dependence->domain,t_source,t_target,
13804- dimension,program->context->NbColumns-2) ;
13805-
13806- solution = pip_solve(system,program->context,-1,pip_options) ;
13807+ new = candl_matrix_violation(orig_dependence, t_source,
13808+ t_target, dimension,
13809+ nb_par);
13810+ solution = pip_solve_osl(new->domain, orig_scop->context, -1, pip_options);
13811
13812 if ((solution != NULL) &&
13813 ((solution->list != NULL) || (solution->condition != NULL)))
13814- violated = 1 ;
13815-
13816- pip_quast_free(solution) ;
13817+ violated = 1;
13818
13819- if (violated)
13820- { new = candl_violation_malloc() ;
13821+ pip_quast_free(solution);
13822
13823- /* We set the various fields with corresponding values. */
13824- new->dependence = dependence ;
13825- new->dimension = dimension ;
13826- new->domain = system ;
13827+ if (violated) {
13828
13829- candl_violation_add(&violation,&now,new) ;
13830+ /* We set the various fields with corresponding values. */
13831+ new->dependence = orig_dependence;
13832+ new->dimension = dimension;
13833+ candl_violation_add(&violation,&now,new);
13834
13835- if (!options->fullcheck)
13836- { pip_options_free(pip_options) ;
13837- return violation ;
13838- }
13839+ if (!options->fullcheck) {
13840+ pip_options_free(pip_options);
13841+ return violation;
13842+ }
13843+ } else if (new) {
13844+ candl_violation_free(new);
13845 }
13846- else
13847- candl_matrix_free(system) ;
13848 }
13849- dependence = dependence->next ;
13850+ orig_dependence = orig_dependence->next;
13851 }
13852
13853- pip_options_free(pip_options) ;
13854- return violation ;
13855+ free(stmts);
13856+
13857+ pip_options_free(pip_options);
13858+
13859+ return violation;
13860 }
13861
Candl - Data Dependence Analysis Tool in the Polyhedral Model
This page took 1.925338 seconds and 4 git commands to generate.