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

Last change on this file since 137 was 137, checked in by rosiere, 14 years ago

Various modif (add test, and vhdl)

  • Property svn:keywords set to Id
File size: 9.5 KB
RevLine 
[2]1#
2# $Id: Makefile.Selftest 137 2010-02-16 12:35:48Z 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
[117]21LIBS                            = -lm $(SYSTEMC_LIBNAME_$(SIMULATOR_SYSTEMC))
[113]22#                                 $(OR1K_LIBNAME) -lbfd 
23
24MODELTECH_LIBRARY               = $(addprefix -lib ,$(addsuffix .a, $(subst -l,$(DIR_LIB)/lib,$(LIBRARY))))
25#MODELTECH_LIBRARY               = $(LIBRARY)
26
[131]27EXEC_PREFIX                     =
28#$(VALGRIND)
[117]29EXEC_PARAMS                     = $(SYSTEMC_EXEC_PARAMS_$(SIMULATOR_SYSTEMC))
[15]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))
[131]32BIN                             = Selftest.x
33EXEC                            = $(DIR_BIN)/$(BIN)
[2]34
[53]35#-----[ Rules ]--------------------------------------------
[2]36.PRECIOUS                       : $(DIR_BIN)/%.x $(DIR_LOG)/%.exec.log
[71]37#.NOTPARALLEL                   : clean clean_all help
[2]38
[117]39vpath   %.cfg   $(DIR_CFG_USER):$(DIR_CFG_GEN)
40vpath   %.x     $(DIR_BIN)
41
[2]42all_selftest                    : test_env $(DIR_OBJ) $(DIR_BIN) $(DIR_LOG)
[48]43                                @\
44                                $(MAKE) library;\
[131]45                                $(MAKE) $(EXEC);
[2]46
[88]47execute_only                    :
[82]48                                @\
49                                $(MAKE) $(EXEC_LOG);                                    \
50                                declare -i all_ok=1;                                    \
51                                for i in $(EXEC_LOG); do                                \
[94]52                                    $(GREP) -q "Timing"  $$i;                           \
53                                    declare -i test_timing=$$?;                         \
[82]54                                    $(GREP) -q "Test OK" $$i;                           \
55                                    declare -i test_ok=$$?;                             \
56                                    $(GREP) -q "Test KO" $$i;                           \
57                                    declare -i test_ko=$$?;                             \
[94]58                                    if $(TEST) $$test_ko -eq 0 -o $$test_ok -ne 0 -o $$test_timing -ne 0;      \
[82]59                                    then all_ok=0;                                      \
60                                    fi;                                                 \
61                                done;                                                   \
62                                if $(TEST) $$all_ok -eq 1;                              \
[83]63                                then $(ECHO) "-------------------| Test OK"; exit 0;    \
64                                else $(ECHO) "-------------------| Test KO"; exit 1;    \
[82]65                                fi;
[2]66
[88]67execute                         : all_selftest
68                                @\
69                                $(MAKE) execute_only;
70
[2]71reconfig                        :
[48]72                                @\
73                                $(MAKE) config_clean;\
74                                $(MAKE) config;
[2]75
76config_clean                    :
[15]77                                @$(RM) $(DIR_CFG_GEN)
[2]78
[15]79config                          : $(DIR_CFG_GEN)
[48]80                                @\
[62]81                                $(ECHO) "Generate configuration";                                                                       \
[2]82                                declare -i  CPT=0;                                                                                      \
[44]83                                declare     files;                                                                                      \
[2]84                                                                                                                                        \
[44]85                                if $(TEST) -f $(CFG_FILE_DEBUG); then                                                                   \
86                                        files=$(CFG_FILE_DEBUG);                                                                        \
87                                else                                                                                                    \
88                                        files=$$($(LS) *.$(CFG_FILE_EXTENSION) );                                                       \
89                                fi;                                                                                                     \
90                                                                                                                                        \
[88]91                                declare -i NB_CONFIG=0;                                                                                 \
92                                declare -i NB_DIGIT=0;                                                                                  \
[44]93                                                                                                                                        \
[88]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                                                                               \
[43]125                                        declare     NAME;                                                                               \
[88]126                                        declare -ai MIN=();                                                                             \
127                                        declare -ai PERIOD=();                                                                          \
128                                        declare -a  RANGE_LOCAL=();                                                                     \
129                                        declare -a  RANGE=();                                                                           \
130                                        declare -a  SIZE=();                                                                            \
[43]131                                        declare -i  IT=0;                                                                               \
[2]132                                                                                                                                        \
[43]133                                        PERIOD[0]=1;                                                                                    \
[2]134                                                                                                                                        \
[78]135                                        while read line; do                                                                             \
[88]136                                                declare -a LINE=($${line});                                                             \
[2]137                                                                                                                                        \
[88]138                                                if $(TEST) $${IT} -eq 0; then                                                           \
[43]139                                                        NAME=$${LINE[0]};                                                               \
140                                                else                                                                                    \
[88]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}]}));               \
[43]146                                                fi;                                                                                     \
[2]147                                                                                                                                        \
[88]148                                                IT=$$(($${IT}+1));                                                                      \
149                                        done < $${file};                                                                                \
[2]150                                                                                                                                        \
[88]151                                        declare -a  DATA=();                                                                            \
152                                        declare -ai ENUM_CONFIG=($$($(DIR_SCRIPT)/range.sh 0 $$(($${PERIOD[$$(($${IT}-1))]}-1))));      \
[43]153                                        declare -ai ENUM_PARAM=($$($(DIR_SCRIPT)/range.sh 1 $${#MIN[*]}));                              \
[88]154                                        declare -i  NB_PARAM=$${#MIN[*]};                                                               \
[43]155                                                                                                                                        \
156                                        $(ECHO) " * File : $$file";                                                                     \
[88]157                                        $(ECHO) "   * They are $${NB_PARAM} parameters";                                                \
158                                        $(ECHO) "   * Generate $${PERIOD[$$(($${IT}-1))]} configurations";                              \
[43]159                                                                                                                                        \
160                                        for i in $${ENUM_CONFIG[*]}; do                                                                 \
161                                                x=$$i;                                                                                  \
162                                                for j in $${ENUM_PARAM[*]}; do                                                          \
[113]163                                                        declare -a RANGE_LOCAL=($${RANGE[$$j]});                                        \
[43]164                                                        DATA[$$j]="$${RANGE_LOCAL[$$((($$x % $${SIZE[$$j]})))]} ";                      \
165                                                        x=$$(($$x/$${SIZE[$$j]}));                                                      \
166                                                done;                                                                                   \
[88]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));                                                                    \
[2]171                                        done;                                                                                           \
172                                done;
173
[131]174$(DIR_LOG)/%.exec.log           : %.cfg  $(EXEC)
[48]175                                @\
176                                $(ECHO) "Execute            : $*";\
[131]177                                export SYSTEMC=$(SYSTEMC_$(SIMULATOR_SYSTEMC)); $(EXEC_PREFIX) $(EXEC) $(EXEC_PARAMS) $* `$(CAT) $<` &> $@; \
[82]178                                declare timing=`$(GREP) -h "Timing"  $@`;               \
[94]179                                $(GREP) -q "Timing"  $@;                                \
180                                declare -i test_timing=$$?;                             \
[82]181                                $(GREP) -q "Test OK" $@;                                \
182                                declare -i test_ok=$$?;                                 \
183                                $(GREP) -q "Test KO" $@;                                \
184                                declare -i test_ko=$$?;                                 \
[115]185                                declare memory_leak=" ";                                \
186                                $(GREP) -q "Leaked memory at" $@;                       \
187                                if $(TEST) $$? -eq 0;                                   \
188                                then memory_leak="*";                                   \
189                                fi;                                                     \
[94]190                                if $(TEST) $$test_ko -ne 0 -a $$test_ok -eq 0 -a $$test_timing -eq 0; \
[115]191                                then echo -e "                     $* ... OK $$memory_leak\t$$timing";\
[82]192                                else echo    "                     $* ... KO";          \
[2]193                                fi;
194
[113]195$(DIR_BIN)/%.x                  : $(SOURCES) $(HEADERS) $(DIR_OBJ) $(DIR_BIN)
[48]196                                @\
197                                $(ECHO) "Linkage            : $*";\
[117]198                                case "${SIMULATOR_SYSTEMC}" in                                                          \
[113]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);                                                     \
[117]216                                        $(SYSTEMC_CXX_$(SIMULATOR_SYSTEMC)) $(LFLAGS) -o $@ $(OBJECTS) $(LIBRARY) $(LIBS);\
[113]217                                        ;;                                                                      \
218                                esac;
[2]219
[113]220$(DIR_BIN) $(DIR_LOG) $(DIR_CFG_GEN) :
[88]221                                @\
222                                $(ECHO) "Create directory   : $@";\
223                                $(MKDIR) $@;
224
225selftest_clean                  : local_clean config_clean
[2]226                                @$(RM)  $(DIR_LOG)              \
[15]227                                        $(DIR_CFG_USER)/*~      \
[131]228                                        $(EXEC)                 \
[2]229                                        *.vhdl                  \
[31]230                                        *.pos                   \
[2]231                                        *.stat                  \
[88]232                                        *.log                   \
[62]233                                        *.dot                   \
234                                        *.txt                   \
[3]235                                        generated_by_systemcass \
[88]236                                        semantic.cache          \
[137]237                                        gmon.out                \
[48]238                                        core*;
[2]239
[88]240selftest_clean_all              : library_clean
[113]241                                @\
242                                $(RM) $(DIR_BIN)
[88]243
[2]244selftest_help                   :
[48]245                                @\
[53]246                                $(ECHO) " -----[ Selftest ]-----------------------------------";\
[48]247                                $(ECHO) "";\
248                                $(ECHO) " * all_selftest         : compile all c++ file and execute";\
249                                $(ECHO) " * execute              : execute all instance";\
[88]250                                $(ECHO) " * execute_only         : execute all instance without rebuild all libraries";\
[48]251                                $(ECHO) " * config               : generate configuration with configuration's file" ;\
252                                $(ECHO) " * reconfig             : regenerate configuration with configuration's file" ;\
253                                $(ECHO) " * clean                : Erase all generate files";\
254                                $(ECHO) " * clean_all            : Clean + Erase all dependant library";\
255                                $(ECHO) " * help                 : print this text";\
256                                $(ECHO) "";
[2]257
258help                            :
[48]259                                @\
[62]260                                $(MAKE) common_help  ; \
[71]261                                $(MAKE) synthesis_help;\
[48]262                                $(MAKE) selftest_help;
[2]263
264clean                           :
[48]265                                @\
266                                $(MAKE) common_clean ;\
267                                $(MAKE) synthesis_clean ;\
268                                $(MAKE) selftest_clean;
[2]269
270clean_all                       :
[48]271                                @\
272                                $(MAKE) clean ;\
273                                $(MAKE) selftest_clean_all;
Note: See TracBrowser for help on using the repository browser.