# 
# $Id: Makefile 123 2009-06-08 20:43:30Z rosiere $
# 
# [ Description ]
# 
# Makefile
# 

include				Makefile.defs

#-----[ Specint variable ]--------------------------------------------------------

# BENCHS				= 	164.gzip	\
# 					175.vpr   	\
# 					176.gcc   	\
# 					181.mcf		\
# 					255.vortex	\
# 					256.bzip2	\
# 					300.twolf 

BENCHS				= 	164.gzip


SPECINT2000_PATH		= /users/cao/kane/Project/SPEC_CPU2000/benchspec/CINT2000
SPECINT2000_PATHS		= $(addprefix $(SPECINT2000_PATH)/, $(BENCHS))

SPECINT2000_PATH_INC		= $(addprefix -I, $(addsuffix /src, $(SPECINT2000_PATHS)))
SPECINT2000_PATH_SRC		= $(wildcard $(addsuffix /src    , $(SPECINT2000_PATHS)))
SPECINT2000_OBJECTS    		= $(foreach bench,$(BENCHS),$(addprefix $(DIR_OBJ)/$(bench)_,   $(addsuffix .o, $(basename $(notdir $(wildcard $(SPECINT2000_PATH)/$(bench)/src/*.c))))))

#-----[ Directory ]---------------------------------------------------------------

DIR_SOFT			= ..

DIR_SRC				= ./src
DIR_C				= $(DIR_SRC)/c
DIR_ASM				= $(DIR_SRC)/asm
DIR_SYS				= $(DIR_SRC)/sys
DIR_INC		       		= $(DIR_SRC)/include
DIR_LDSCRIPT			= $(NEWLIB)/lib/

INCDIR 				= $(NEWLIB_INCDIR) -I$(DIR_INC) $(SPECINT2000_PATH_INC)
LIBDIR				= $(NEWLIB_LIBDIR)
LIBNAME				= $(NEWLIB_LIBNAME)

FILE_BENCH			= $(DIR_INC)/workload.h
FILE_BENCH_SED			= $(DIR_INC)/workload.h.sed

#-----[ Flags ]-------------------------------------------------------------------

FLAGS				= -DSPECINT2000_PATH=\"$(SPECINT2000_PATH)\" -DNB_THREAD_MAX=$(NB_THREAD_MAX)
FLAGS_164.gzip			=
FLAGS_175.vpr			= -DSPEC_CPU2000
FLAGS_176.gcc			=
FLAGS_181.mcf			= -DWANT_STDC_PROTO
FLAGS_186.crafty		=
FLAGS_197.parser		=
FLAGS_252.eon			=
FLAGS_253.perlbmk		=
FLAGS_254.gap			=
FLAGS_255.vortex		=
FLAGS_256.bzip2			= -DWANT_STDC_PROTO
FLAGS_300.twolf			= -DSPEC_CPU2000

#-----[ Files ]-------------------------------------------------------------------
OBJECTS				= 	$(NEWLIB)/lib/*.o \
					$(patsubst $(DIR_ASM)/%.s,$(DIR_OBJ)/%.o,$(wildcard $(DIR_ASM)/*.s))	\
					$(patsubst $(DIR_SYS)/%.s,$(DIR_OBJ)/%.o,$(wildcard $(DIR_SYS)/*.s))	\
					$(patsubst $(DIR_C)/%.c,$(DIR_OBJ)/%.o,$(wildcard $(DIR_C)/*.c))	\
					$(SPECINT2000_OBJECTS)

vpath	%.h	$(SPECINT2000_PATH_INC)
# vpath	%.c	$(SPECINT2000_PATH_SRC)

include				$(DIR_SOFT)/Makefile.Software

$(DIR_OBJ)/164.gzip_%.o		: $(SPECINT2000_PATH)/164.gzip/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_164.gzip)    -o $@   -c $^ ;

$(DIR_OBJ)/175.vpr_%.o		: $(SPECINT2000_PATH)/175.vpr/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_175.vpr)     -o $@   -c $^ ;

$(DIR_OBJ)/176.gcc_%.o		: $(SPECINT2000_PATH)/176.gcc/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_176.gcc)     -o $@   -c $^ ;

$(DIR_OBJ)/181.mcf_%.o		: $(SPECINT2000_PATH)/181.mcf/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_181.mcf)     -o $@   -c $^ ;

$(DIR_OBJ)/186.crafty_%.o	: $(SPECINT2000_PATH)/186.crafty/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_186.crafty)     -o $@   -c $^ ;

$(DIR_OBJ)/255.vortex_%.o	: $(SPECINT2000_PATH)/255.vortex/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_255.vortex)  -o $@   -c $^ ;

$(DIR_OBJ)/197.parser_%.o	: $(SPECINT2000_PATH)/197.parser/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_197.parser)  -o $@   -c $^ ;

$(DIR_OBJ)/252.eon_%.o		: $(SPECINT2000_PATH)/252.eon/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_252.eon)  -o $@   -c $^ ;

$(DIR_OBJ)/253.perlbmk_%.o	: $(SPECINT2000_PATH)/253.perlbmk/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_253.perlbmk)  -o $@   -c $^ ;

$(DIR_OBJ)/254.gap_%.o		: $(SPECINT2000_PATH)/254.gap/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_254.gap)  -o $@   -c $^ ;

$(DIR_OBJ)/256.bzip2_%.o	: $(SPECINT2000_PATH)/256.bzip2/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_256.bzip2)   -o $@   -c $^ ;

$(DIR_OBJ)/300.twolf_%.o	: $(SPECINT2000_PATH)/300.twolf/src/%.c
				@\
                                $(ECHO) "Compilation        : $*.c";		\
				$(OR32_CC) $(OR32_CC_OPT) $(FLAGS_300.twolf)   -o $@   -c $^ ;

list				:
				@\
				for bench in $(BENCHS); do	\
					$(ECHO) $${bench};		\
				done;

print				:
				@$(CAT) $(FILE_BENCH);

define                        	:
				@                                                                               \
				$(ECHO) "Give a Number of thread (1 by default, Max : $(NB_THREAD_MAX)) : ";    \
				declare -i NB_THREAD=0;                                                         \
				$(READ) NB_THREAD;                                                              \
				                                                                                \
				if $(TEST) "$$NB_THREAD" -ge "$(NB_THREAD_MAX)";                                \
				then                                                                            \
				        NB_THREAD=$(NB_THREAD_MAX);                                             \
				else                                                                            \
				        if $(TEST) "$$NB_THREAD" -eq 0;                                         \
				        then                                                                    \
				                NB_THREAD=1;                                                    \
				        fi;                                                                     \
				fi;                                                                             \
				                                                                                \
				$(ECHO) "You want $$NB_THREAD thread(s)";                                       \
				$(ECHO) "";                                                                     \
				declare -i NUM_THREAD=0;                                                        \
				declare    WORKLOAD="";                                                         \
				declare -i PREVIOUS=1;                                                          \
				declare -i CPT=2;                                                               \
				declare -a BENCHS;                                                              \
				                                                                                \
				BENCHS[0]="previous choose";                                                    \
				BENCHS[1]="none";                                                               \
				for benchs in $(BENCHS); do				                        \
				        BENCHS[$$CPT]=$${benchs/"."/"_"};                                       \
				        CPT=$$(($$CPT+1));                                              \
				done;                                                                           \
				                                                                                \
				$(ECHO) "For each Thread, you must select a number of benchmark (0 by default)";\
				$(ECHO) "";                                                                     \
				                                                                                \
				while [ $$NUM_THREAD -lt $$NB_THREAD ];                                         \
				do                                                                              \
				        if $(TEST) $$NUM_THREAD -ne 0;                                          \
				        then                                                                    \
				                WORKLOAD=$$WORKLOAD",\n";                                       \
				        fi;                                                                     \
				                                                                                \
				        $(ECHO) "For Thread[$$NUM_THREAD] .....";                               \
				        declare -i NUM_BENCH;                                                   \
				                                                                                \
				        $(ECHO) "0) previous choose  : $${BENCHS[$$PREVIOUS]}";                 \
				        CPT=1;                                                                  \
				        while [ $$CPT -lt $${#BENCHS[*]} ];                                     \
				        do                                                                      \
				                $(ECHO) "$$CPT) $${BENCHS[$$CPT]}";                             \
				                CPT=$$(($$CPT+1));                                              \
				        done;                                                                   \
				        $(READ) NUM_BENCH;                                                      \
				                                                                                \
				        if $(TEST) "$$NUM_BENCH" -ge "$$CPT";                                   \
				        then                                                                    \
				                NUM_BENCH=0;                                                    \
				        fi;                                                                     \
				                                                                                \
				        if $(TEST) "$$NUM_BENCH" -eq "0";                                       \
				        then                                                                    \
				                NUM_BENCH=$$PREVIOUS;                                           \
				        else                                                                    \
				                PREVIOUS=$$NUM_BENCH;                                           \
				        fi;                                                                     \
				                                                                                \
				        $(ECHO) "Benchmark selected  : $${BENCHS[$$NUM_BENCH]}";                \
				        $(ECHO) "";                                                             \
				                                                                                \
				        WORKLOAD=$$WORKLOAD"\t(void *) run_$${BENCHS[$$NUM_BENCH]}";            \
				        NUM_THREAD=$$(($$NUM_THREAD+1));                                        \
				done;                                                                           \
				$(ECHO) "";                                                                     \
				$(ECHO) "Generate the file :  $(FILE_BENCH)";                                   \
				$(CAT)  $(FILE_BENCH_SED) |$(SED) "s/@WORKLOAD/$$WORKLOAD/" > $(FILE_BENCH);    \
				$(RM)   $$$$;                                                                   \
				$(ECHO) "";


workload			:
				@                                                                               \
				$(ECHO) "Give a Number of thread (1 by default, Max : $(NB_THREAD_MAX)) : ";    \
				declare -i NB_THREAD=0;                                                         \
				$(READ) NB_THREAD;                                                              \
				                                                                                \
				if $(TEST) "$$NB_THREAD" -ge "$(NB_THREAD_MAX)";                                \
				then                                                                            \
				        NB_THREAD=$(NB_THREAD_MAX);                                             \
				else                                                                            \
				        if $(TEST) "$$NB_THREAD" -eq 0;                                         \
				        then                                                                    \
				                NB_THREAD=1;                                                    \
				        fi;                                                                     \
				fi;                                                                             \
				                                                                                \
				$(ECHO) " * You want $$NB_THREAD thread(s)";                                    \
				$(ECHO) "";                                                                     \
				$(ECHO) "List of all Benchmark";                                                \
				declare -i CPT=1;                                                               \
				declare -a BENCHS;                                                              \
				                                                                                \
				for benchs in $(BENCHS); do                        \
				        $(ECHO) " $$CPT) $$benchs";                                     \
				        BENCHS[$$CPT]=$${benchs/"."/"_"};                               \
				        CPT=$$(($$CPT+1));                                              \
				done;                                                                           \
				$(ECHO) "";                                                                     \
				$(ECHO) "Enter the list benchmark (0 to stop)";                                 \
				declare -i NUM_BENCH;                                                           \
				CPT=1;                                                                          \
				declare -a -i WORKLOAD;                                                         \
				                                                                                \
				while $(TEST) 1; do                                                             \
				        $(READ) NUM_BENCH;                                                      \
				                                                                                \
				        if $(TEST) $$NUM_BENCH -eq 0; then                                      \
				                break;                                                          \
				        fi;                                                                     \
				                                                                                \
				        if $(TEST) $$NUM_BENCH -gt $${#BENCHS[*]}; then                         \
				                $(ECHO) " * Out of limit, retry ...";                           \
				        else                                                                    \
				                echo " * $${BENCHS[$$NUM_BENCH]}";                              \
				                WORKLOAD[$$CPT]=$$NUM_BENCH;                                    \
				                CPT=$$(($$CPT+1));                                              \
				        fi;                                                                     \
				done;                                                                           \
				                                                                                \
				if $(TEST) $$NB_THREAD -gt $${#WORKLOAD[*]}; then                               \
				        $(ECHO) "Error : The number of bench in the workload ($${#WORKLOAD[*]}) is < at the number of thread ($$NB_THREAD)"; \
				        exit;                                                                   \
				fi;                                                                             \
				$(ECHO) "";                                                                     \
				$(ECHO) "Generate the workload";                                                \
				                                                                                \
				declare -i NB_ITERATION=1;                                                      \
				CPT=$$(($$NB_THREAD+1));                                                        \
				while $(TEST) $$CPT -le $${#WORKLOAD[*]}; do                                    \
				        NB_ITERATION=$$(($$NB_ITERATION*$$CPT));                                \
				        CPT=$$(($$CPT+1));                                                      \
				done;                                                                           \
				CPT=$$(($${#WORKLOAD[*]}-$$NB_THREAD));                                         \
				while $(TEST) $$CPT -gt 0; do                                                   \
				        NB_ITERATION=$$(($$NB_ITERATION/$$CPT));                                \
				        CPT=$$(($$CPT-1));                                                      \
				done;                                                                           \
				$(ECHO) " * $$NB_ITERATION Workloads (n!/(p!*(n-p)!))";                         \
				                                                                                \
				declare -a -i PTR;                                                              \
				CPT=1;                                                                          \
				while $(TEST) $$CPT -le $$NB_THREAD; do                                         \
				        PTR[$$CPT]=$$(($$NB_THREAD-$$CPT+1));                                   \
				        CPT=$$(($$CPT+1));                                                      \
				done;                                                                           \
				                                                                                \
				CPT=0;                                                                          \
				declare -i IT;                                                                  \
				declare -a -i OVF;                                                              \
				declare -a -i NB_OVF;                                                           \
				                                                                                \
				while $(TEST) $$CPT -lt $$NB_ITERATION; do                                      \
					declare COMMAND="$$NB_THREAD\n";						\
				        echo -ne "   - [$$CPT]\t";                                              \
				                                                                                \
				        OVF[0]=0;                                                               \
				        NB_OVF=0;                                                               \
				        if $(TEST) $${PTR[1]} -ge $${#WORKLOAD[*]}; then                        \
				                OVF[0]=1;                                                       \
				        fi;                                                                     \
				                                                                                \
				        IT=1;                                                                   \
				        while $(TEST) $$IT -le $$NB_THREAD; do                                  \
				                echo -ne " $${BENCHS[$${WORKLOAD[$${PTR[$$IT]}]}]}\t";          \
				                                                                                \
						COMMAND="$${COMMAND}$$(($${WORKLOAD[$${PTR[$$IT]}]}+1))\n";				\
				                OVF[$$(($$IT))]=0;                                              \
				                if $(TEST) $${OVF[$$(($$IT-1))]} -eq 1 ; then                   \
				                        if $(TEST) $$(($${PTR[$$IT]}+$$NB_OVF)) -ge $${#WORKLOAD[*]}; then      \
				                                OVF[$$IT]=1;                                    \
				                                NB_OVF=$$(($$NB_OVF+1));                        \
				                        fi;                                                     \
				                fi;                                                             \
				                                                                                \
				                IT=$$(($$IT+1));                                                \
				        done;                                                                   \
				        echo "";                                                                \
				                                                                                \
					$(ECHO) -e $${COMMAND} | $(MAKE) define;				\
					$(MAKE) $(DIR_BIN)/$(EXE)_$${CPT}.x;					\
				                                                                                \
				        PTR[1]=$$(($${PTR[1]}+1));                                              \
				        IT=$$NB_THREAD;                                                         \
				        while $(TEST) $$IT -ge 1; do                                            \
				                if $(TEST) $${OVF[$$IT]} -eq 1 ; then                           \
				                        PTR[$$(($$IT))]=$${PTR[$$(($$IT+1))]};                  \
				                fi;                                                             \
				                                                                                \
				                if $(TEST) $${OVF[$$(($$IT-1))]} -eq 1 ; then                   \
				                        PTR[$$(($$IT))]=$$(($${PTR[$$IT]}+1));                  \
				                fi;                                                             \
				                IT=$$(($$IT-1));                                                \
				        done;                                                                   \
				                                                                                \
				        CPT=$$(($$CPT+1));                                                      \
				done;                                                                           \
