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

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

1) Write queue with mealy
2) Network : fix bug
3) leak memory

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