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

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

Almost complete design
with Test and test platform

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