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

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

1) add constant method
2) test with systemc 2.2.0

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