source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Makefile.Selftest @ 128

Last change on this file since 128 was 128, checked in by rosiere, 15 years ago

1) Correct bug in link two signal
2) Fix error detected with valgrind
3) modif distexe script

  • Property svn:keywords set to Id
File size: 9.4 KB
Line 
1#
2# $Id: Makefile.Selftest 128 2009-06-26 08:43:23Z rosiere $
3#
4# [ Description ]
5#
6# Makefile
7#
8
9#-----[ Directory ]----------------------------------------
10DIR_BIN                         = $(DIR_TMP)/bin
11DIR_CFG_GEN                     = $(DIR_TMP)/configuration_generated
12DIR_CFG_USER                    = configuration
13DIR_LOG                         = log
14
15#-----[ Variables ]----------------------------------------
16CFG_FILE_EXTENSION              = cfg
17CFG_FILE_DEBUG                  = debug.$(CFG_FILE_EXTENSION)
18
19OBJECTS                         = $(OBJECTS_COMMON)
20
21LIBS                            = -lm $(SYSTEMC_LIBNAME_$(SIMULATOR_SYSTEMC))
22#                                 $(OR1K_LIBNAME) -lbfd 
23
24MODELTECH_LIBRARY               = $(addprefix -lib ,$(addsuffix .a, $(subst -l,$(DIR_LIB)/lib,$(LIBRARY))))
25#MODELTECH_LIBRARY               = $(LIBRARY)
26
27EXEC_PREFIX                     = $(VALGRIND)
28EXEC_PARAMS                     = $(SYSTEMC_EXEC_PARAMS_$(SIMULATOR_SYSTEMC))
29EXEC_LOG                        = $(patsubst $(DIR_CFG_GEN)/%.cfg,$(DIR_LOG)/%.exec.log,$(wildcard $(DIR_CFG_GEN)/*.cfg))       \
30                                  $(patsubst $(DIR_CFG_USER)/%.cfg,$(DIR_LOG)/%.exec.log,$(wildcard $(DIR_CFG_USER)/*.cfg))
31EXEC                            = soft
32
33#-----[ Rules ]--------------------------------------------
34.PRECIOUS                       : $(DIR_BIN)/%.x $(DIR_LOG)/%.exec.log
35#.NOTPARALLEL                   : clean clean_all help
36
37vpath   %.cfg   $(DIR_CFG_USER):$(DIR_CFG_GEN)
38vpath   %.x     $(DIR_BIN)
39
40all_selftest                    : test_env $(DIR_OBJ) $(DIR_BIN) $(DIR_LOG)
41                                @\
42                                $(MAKE) library;\
43                                $(MAKE) $(DIR_BIN)/$(EXEC).x;
44
45execute_only                    :
46                                @\
47                                $(MAKE) $(EXEC_LOG);                                    \
48                                declare -i all_ok=1;                                    \
49                                for i in $(EXEC_LOG); do                                \
50                                    $(GREP) -q "Timing"  $$i;                           \
51                                    declare -i test_timing=$$?;                         \
52                                    $(GREP) -q "Test OK" $$i;                           \
53                                    declare -i test_ok=$$?;                             \
54                                    $(GREP) -q "Test KO" $$i;                           \
55                                    declare -i test_ko=$$?;                             \
56                                    if $(TEST) $$test_ko -eq 0 -o $$test_ok -ne 0 -o $$test_timing -ne 0;      \
57                                    then all_ok=0;                                      \
58                                    fi;                                                 \
59                                done;                                                   \
60                                if $(TEST) $$all_ok -eq 1;                              \
61                                then $(ECHO) "-------------------| Test OK"; exit 0;    \
62                                else $(ECHO) "-------------------| Test KO"; exit 1;    \
63                                fi;
64
65execute                         : all_selftest
66                                @\
67                                $(MAKE) execute_only;
68
69reconfig                        :
70                                @\
71                                $(MAKE) config_clean;\
72                                $(MAKE) config;
73
74config_clean                    :
75                                @$(RM) $(DIR_CFG_GEN)
76
77config                          : $(DIR_CFG_GEN)
78                                @\
79                                $(ECHO) "Generate configuration";                                                                       \
80                                declare -i  CPT=0;                                                                                      \
81                                declare     files;                                                                                      \
82                                                                                                                                        \
83                                if $(TEST) -f $(CFG_FILE_DEBUG); then                                                                   \
84                                        files=$(CFG_FILE_DEBUG);                                                                        \
85                                else                                                                                                    \
86                                        files=$$($(LS) *.$(CFG_FILE_EXTENSION) );                                                       \
87                                fi;                                                                                                     \
88                                                                                                                                        \
89                                declare -i NB_CONFIG=0;                                                                                 \
90                                declare -i NB_DIGIT=0;                                                                                  \
91                                                                                                                                        \
92                                for file in $${files}; do                                                                               \
93                                        declare -ai PERIOD=();                                                                          \
94                                        declare -i  IT=0;                                                                               \
95                                                                                                                                        \
96                                        PERIOD[0]=1;                                                                                    \
97                                                                                                                                        \
98                                        while read line; do                                                                             \
99                                                declare -a LINE=($${line});                                                             \
100                                                                                                                                        \
101                                                if $(TEST) $${IT} -ne 0; then                                                           \
102                                                        declare -a RANGE_LOCAL=($$($(DIR_SCRIPT)/range.sh $${LINE[0]} $${LINE[1]} $${LINE[2]}));        \
103                                                        declare -i SIZE=$${#RANGE_LOCAL[*]};                                            \
104                                                        PERIOD[$${IT}]=$$(($${PERIOD[$$(($${IT}-1))]}*$${SIZE}));                       \
105                                                fi;                                                                                     \
106                                                                                                                                        \
107                                                IT=$$(($${IT}+1));                                                                      \
108                                        done < $${file};                                                                                \
109                                                                                                                                        \
110                                        NB_CONFIG=$$(($${NB_CONFIG} + $${PERIOD[$$(($${IT}-1))]}));                                     \
111                                done;                                                                                                   \
112                                                                                                                                        \
113                                $(ECHO) " * They are $${NB_CONFIG} configurations";                                                     \
114                                                                                                                                        \
115                                declare -i x=$${NB_CONFIG};                                                                             \
116                                                                                                                                        \
117                                while test $${x} -ne 0; do                                                                              \
118                                        NB_DIGIT=$$(($${NB_DIGIT} + 1));                                                                \
119                                        x=$$(($${x} / 10));                                                                             \
120                                done;                                                                                                   \
121                                                                                                                                        \
122                                for file in $${files}; do                                                                               \
123                                        declare     NAME;                                                                               \
124                                        declare -ai MIN=();                                                                             \
125                                        declare -ai PERIOD=();                                                                          \
126                                        declare -a  RANGE_LOCAL=();                                                                     \
127                                        declare -a  RANGE=();                                                                           \
128                                        declare -a  SIZE=();                                                                            \
129                                        declare -i  IT=0;                                                                               \
130                                                                                                                                        \
131                                        PERIOD[0]=1;                                                                                    \
132                                                                                                                                        \
133                                        while read line; do                                                                             \
134                                                declare -a LINE=($${line});                                                             \
135                                                                                                                                        \
136                                                if $(TEST) $${IT} -eq 0; then                                                           \
137                                                        NAME=$${LINE[0]};                                                               \
138                                                else                                                                                    \
139                                                        MIN[$${IT}]=$${LINE[0]};                                                        \
140                                                        RANGE[$${IT}]=$$($(DIR_SCRIPT)/range.sh $${LINE[0]} $${LINE[1]} $${LINE[2]});   \
141                                                        RANGE_LOCAL=($${RANGE[$${IT}]});                                                \
142                                                        SIZE[$${IT}]=$${#RANGE_LOCAL[*]};                                               \
143                                                        PERIOD[$${IT}]=$$(($${PERIOD[$$(($${IT}-1))]}*$${SIZE[$${IT}]}));               \
144                                                fi;                                                                                     \
145                                                                                                                                        \
146                                                IT=$$(($${IT}+1));                                                                      \
147                                        done < $${file};                                                                                \
148                                                                                                                                        \
149                                        declare -a  DATA=();                                                                            \
150                                        declare -ai ENUM_CONFIG=($$($(DIR_SCRIPT)/range.sh 0 $$(($${PERIOD[$$(($${IT}-1))]}-1))));      \
151                                        declare -ai ENUM_PARAM=($$($(DIR_SCRIPT)/range.sh 1 $${#MIN[*]}));                              \
152                                        declare -i  NB_PARAM=$${#MIN[*]};                                                               \
153                                                                                                                                        \
154                                        $(ECHO) " * File : $$file";                                                                     \
155                                        $(ECHO) "   * They are $${NB_PARAM} parameters";                                                \
156                                        $(ECHO) "   * Generate $${PERIOD[$$(($${IT}-1))]} configurations";                              \
157                                                                                                                                        \
158                                        for i in $${ENUM_CONFIG[*]}; do                                                                 \
159                                                x=$$i;                                                                                  \
160                                                for j in $${ENUM_PARAM[*]}; do                                                          \
161                                                        declare -a RANGE_LOCAL=($${RANGE[$$j]});                                        \
162                                                        DATA[$$j]="$${RANGE_LOCAL[$$((($$x % $${SIZE[$$j]})))]} ";                      \
163                                                        x=$$(($$x/$${SIZE[$$j]}));                                                      \
164                                                done;                                                                                   \
165                                                declare NUM=$$($(PRINTF) %.$${NB_DIGIT}d $${CPT});                                      \
166                                                $(ECHO) $${DATA[*]} > "$(DIR_CFG_GEN)/$${NAME}_$${NUM}.cfg";                            \
167                                                $(ECHO) "   - {$${NUM}} $${DATA[*]}";                                                   \
168                                                CPT=$$(($${CPT}+1));                                                                    \
169                                        done;                                                                                           \
170                                done;
171
172$(DIR_LOG)/%.exec.log           : %.cfg  $(EXEC).x
173                                @\
174                                $(ECHO) "Execute            : $*";\
175                                export SYSTEMC=$(SYSTEMC_$(SIMULATOR_SYSTEMC)); $(EXEC_PREFIX) $(DIR_BIN)/$(EXEC).x $(EXEC_PARAMS) $* `$(CAT) $<` &> $@; \
176                                declare timing=`$(GREP) -h "Timing"  $@`;               \
177                                $(GREP) -q "Timing"  $@;                                \
178                                declare -i test_timing=$$?;                             \
179                                $(GREP) -q "Test OK" $@;                                \
180                                declare -i test_ok=$$?;                                 \
181                                $(GREP) -q "Test KO" $@;                                \
182                                declare -i test_ko=$$?;                                 \
183                                declare memory_leak=" ";                                \
184                                $(GREP) -q "Leaked memory at" $@;                       \
185                                if $(TEST) $$? -eq 0;                                   \
186                                then memory_leak="*";                                   \
187                                fi;                                                     \
188                                if $(TEST) $$test_ko -ne 0 -a $$test_ok -eq 0 -a $$test_timing -eq 0; \
189                                then echo -e "                     $* ... OK $$memory_leak\t$$timing";\
190                                else echo    "                     $* ... KO";          \
191                                fi;
192
193$(DIR_BIN)/%.x                  : $(SOURCES) $(HEADERS) $(DIR_OBJ) $(DIR_BIN)
194                                @\
195                                $(ECHO) "Linkage            : $*";\
196                                case "${SIMULATOR_SYSTEMC}" in                                                          \
197                                    "modelsim")                                                                 \
198                                        $(MAKE) vhdl_package;                                                   \
199                                        $(MAKE) vhdl_entity;                                                    \
200                                        $(MODELTECH_SCCOM) -work $(DIR_WORK) $(CFLAGS) $(SOURCES);              \
201                                        $(MODELTECH_SCCOM) -work $(DIR_WORK) $(MODELTECH_LIBRARY) $(LFLAGS) $(LIBS) -link;\
202                                        $(ECHO) "#!$(SHELL)"                                              > $@; \
203                                        $(ECHO) "cd $${PWD};"                                            >> $@; \
204                                        $(ECHO) 'declare args;'                                          >> $@; \
205                                        $(ECHO) 'for i in $${*}; do'                                     >> $@; \
206                                        $(ECHO) '    args=$${args}" -sc_arg $${i}";'                     >> $@; \
207                                        $(ECHO) 'done;'                                                  >> $@; \
208                                        $(ECHO) "$(MODELTECH_VSIM) -novopt "'$${args}'" $(MODELTECH_LIBRARY) $(DIR_WORK).top;" >> $@; \
209                                        $(ECHO) "cd -;"                                                  >> $@; \
210                                        $(CHMOD) +x $@;                                                         \
211                                        ;;                                                                      \
212                                    *)                                                                          \
213                                        $(MAKE) $(OBJECTS);                                                     \
214                                        $(SYSTEMC_CXX_$(SIMULATOR_SYSTEMC)) $(LFLAGS) -o $@ $(OBJECTS) $(LIBRARY) $(LIBS);\
215                                        ;;                                                                      \
216                                esac;
217
218$(DIR_BIN) $(DIR_LOG) $(DIR_CFG_GEN) :
219                                @\
220                                $(ECHO) "Create directory   : $@";\
221                                $(MKDIR) $@;
222
223selftest_clean                  : local_clean config_clean
224                                @$(RM)  $(DIR_LOG)              \
225                                        $(DIR_CFG_USER)/*~      \
226                                        $(DIR_BIN)/$(EXEC).x    \
227                                        *.vhdl                  \
228                                        *.pos                   \
229                                        *.stat                  \
230                                        *.log                   \
231                                        *.dot                   \
232                                        *.txt                   \
233                                        generated_by_systemcass \
234                                        semantic.cache          \
235                                        core*;
236
237selftest_clean_all              : library_clean
238                                @\
239                                $(RM) $(DIR_BIN)
240
241selftest_help                   :
242                                @\
243                                $(ECHO) " -----[ Selftest ]-----------------------------------";\
244                                $(ECHO) "";\
245                                $(ECHO) " * all_selftest         : compile all c++ file and execute";\
246                                $(ECHO) " * execute              : execute all instance";\
247                                $(ECHO) " * execute_only         : execute all instance without rebuild all libraries";\
248                                $(ECHO) " * config               : generate configuration with configuration's file" ;\
249                                $(ECHO) " * reconfig             : regenerate configuration with configuration's file" ;\
250                                $(ECHO) " * clean                : Erase all generate files";\
251                                $(ECHO) " * clean_all            : Clean + Erase all dependant library";\
252                                $(ECHO) " * help                 : print this text";\
253                                $(ECHO) "";
254
255help                            :
256                                @\
257                                $(MAKE) common_help  ; \
258                                $(MAKE) synthesis_help;\
259                                $(MAKE) selftest_help;
260
261clean                           :
262                                @\
263                                $(MAKE) common_clean ;\
264                                $(MAKE) synthesis_clean ;\
265                                $(MAKE) selftest_clean;
266
267clean_all                       :
268                                @\
269                                $(MAKE) clean ;\
270                                $(MAKE) selftest_clean_all;
Note: See TracBrowser for help on using the repository browser.