diff mbox series

[v3,43/46] tests/tcg/Makefile: update to be called from Makefile.target

Message ID 20180424152405.10304-44-alex.bennee@linaro.org
State New
Headers show
Series fix building of tests/tcg | expand

Commit Message

Alex Bennée April 24, 2018, 3:24 p.m. UTC 
This make is now invoked from each individual target make with the
appropriate CC and EXTRA_CFLAGS set for each guest. It then includes
additional Makefile.targets from:

  - tests/tcg/multiarch (always)
  - tests/tcg/$(TARGET_BASE_ARCH) (if available)
  - tests/tcg/$(TARGET_NAME)

The order is important as the later Makefile's may want to suppress
TESTS from it's base arch profile. Each included Makefile.target is
responsible for adding TESTS as well as defining any special build
instructions for individual tests.

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>


---
v2
  - cleaner approach to include sub makefiles
  - move TESTS/VPATH manipulation into sub-makefile
  - avoid double inclusion when TARGET_BASE_ARCH==TARGET_NAME
---
 tests/tcg/Makefile | 162 +++++++++++++++------------------------------
 1 file changed, 53 insertions(+), 109 deletions(-)

-- 
2.17.0

Comments

Richard Henderson April 25, 2018, 9:26 p.m. UTC | #1 
On 04/24/2018 05:24 AM, Alex Bennée wrote:
> +run-%: %

> +	$(call quiet-command, $(QEMU) $< > $<.out, "TEST", "$< on $(TARGET_NAME)")


I've just had an x86_64 guest test run for 70 minutes.  We need to limit the
amount of time spent here in some way, with excessive time reported as test
failure.

One potential way would be to add "ulimit -t $TIMEOUT" to the subshell before
running qemu.  A default TIMEOUT might be e.g. 15 seconds.  I'm not sure what
we should expect for the largest test on the smallest hosts...


r~
Alex Bennée April 26, 2018, 9:30 a.m. UTC | #2 
Richard Henderson <richard.henderson@linaro.org> writes:

> On 04/24/2018 05:24 AM, Alex Bennée wrote:

>> +run-%: %

>> +	$(call quiet-command, $(QEMU) $< > $<.out, "TEST", "$< on $(TARGET_NAME)")

>

> I've just had an x86_64 guest test run for 70 minutes.  We need to limit the

> amount of time spent here in some way, with excessive time reported as test

> failure.

>

> One potential way would be to add "ulimit -t $TIMEOUT" to the subshell before

> running qemu.  A default TIMEOUT might be e.g. 15 seconds.  I'm not sure what

> we should expect for the largest test on the smallest hosts...


Sounds reasonable - test-i386-fprem is probably the longest - I'm not
sure it needs to be so exhaustive.

>

>

> r~



--
Alex Bennée
Richard Henderson April 26, 2018, 8:51 p.m. UTC | #3 
On 04/25/2018 11:30 PM, Alex Bennée wrote:
> 

> Richard Henderson <richard.henderson@linaro.org> writes:

> 

>> On 04/24/2018 05:24 AM, Alex Bennée wrote:

>>> +run-%: %

>>> +	$(call quiet-command, $(QEMU) $< > $<.out, "TEST", "$< on $(TARGET_NAME)")

>>

>> I've just had an x86_64 guest test run for 70 minutes.  We need to limit the

>> amount of time spent here in some way, with excessive time reported as test

>> failure.

>>

>> One potential way would be to add "ulimit -t $TIMEOUT" to the subshell before

>> running qemu.  A default TIMEOUT might be e.g. 15 seconds.  I'm not sure what

>> we should expect for the largest test on the smallest hosts...

> 

> Sounds reasonable - test-i386-fprem is probably the longest - I'm not

> sure it needs to be so exhaustive.


Better, not via ulimit but via something that measures wall time.  That way we
don't stall on e.g. a locked mutex when the child isn't spinning in a loop as
it was here.

I'd guess a small python script would be most maintainable...


r~
diff mbox series

Patch

diff --git a/tests/tcg/Makefile b/tests/tcg/Makefile
index e12395117a..2116fea915 100644
--- a/tests/tcg/Makefile
+++ b/tests/tcg/Makefile
@@ -1,125 +1,69 @@ 
+# -*- Mode: makefile -*-
+#
+# TCG tests
+#
+# These are complicated by the fact we want to build them for guest
+# systems. This requires knowing what guests we are building and which
+# ones we have cross-compilers for or docker images with
+# cross-compilers.
+#
+# The tests themselves should be as minimal as possible as
+# cross-compilers don't always have a large amount of libraries
+# available.
+#
+# We only include the host build system for SRC_PATH and we don't
+# bother with the common rules.mk. We expect CC/LD to have been set for
+# us from the parent make as well as being passed EXTRA_CFLAGS.
+#
+# We also expect to be in the tests build dir for the FOO-linux-user.
+#
+
 -include ../../config-host.mak
--include $(SRC_PATH)/rules.mak
+-include ../config-target.mak
 
-$(call set-vpath, $(SRC_PATH)/tests/tcg)
+quiet-command = $(if $(V),$1,$(if $(2),@printf "  %-7s %s\n" $2 $3 && $1, @$1))
 
-QEMU=../../i386-linux-user/qemu-i386
-QEMU_X86_64=../../x86_64-linux-user/qemu-x86_64
-CC_X86_64=$(CC_I386) -m64
+# Tests we are building
+TESTS=
 
-QEMU_INCLUDES += -I../..
-CFLAGS=-Wall -O2 -g -fno-strict-aliasing
-#CFLAGS+=-msse2
+# Start with a blank slate, the build targets get to add stuff first
+CFLAGS=
+QEMU_CFLAGS=
 LDFLAGS=
 
-# TODO: automatically detect ARM and MIPS compilers, and run those too
-
-# runcom maps page 0, so it requires root privileges
-# also, pi_10.com runs indefinitely
+# The QEMU for this TARGET
+QEMU=../qemu-$(TARGET_NAME)
 
-I386_TESTS=hello-i386 \
-	   sha1-i386 \
-	   test-i386 \
-	   test-i386-fprem \
-	   # runcom
-
-# native i386 compilers sometimes are not biarch.  assume cross-compilers are
-ifneq ($(ARCH),i386)
-I386_TESTS+=run-test-x86_64
+# The order we include is important. We include multiarch, base arch and finally arch
+-include $(SRC_PATH)/tests/tcg/multiarch/Makefile.target
+-include $(SRC_PATH)/tests/tcg/$(TARGET_BASE_ARCH)/Makefile.target
+ifneq ($(TARGET_BASE_ARCH),$(TARGET_NAME))
+-include $(SRC_PATH)/tests/tcg/$(TARGET_NAME)/Makefile.target
 endif
 
-TESTS = test_path
-ifneq ($(call find-in-path, $(CC_I386)),)
-TESTS += $(I386_TESTS)
-endif
-
-all: $(patsubst %,run-%,$(TESTS))
-test: all
-
-# rules to run tests
-
-.PHONY: $(patsubst %,run-%,$(TESTS))
-
-run-%: %
-	-$(QEMU) ./$*
-
-run-hello-i386: hello-i386
-run-sha1-i386: sha1-i386
-
-run-test-i386: test-i386
-	./test-i386 > test-i386.ref
-	-$(QEMU) test-i386 > test-i386.out
-	@if diff -u test-i386.ref test-i386.out ; then echo "Auto Test OK"; fi
-
-run-test-i386-fprem: test-i386-fprem
-	./test-i386-fprem > test-i386-fprem.ref
-	-$(QEMU) test-i386-fprem > test-i386-fprem.out
-	@if diff -u test-i386-fprem.ref test-i386-fprem.out ; then echo "Auto Test OK"; fi
-
-run-test-x86_64: test-x86_64
-	./test-x86_64 > test-x86_64.ref
-	-$(QEMU_X86_64) test-x86_64 > test-x86_64.out
-	@if diff -u test-x86_64.ref test-x86_64.out ; then echo "Auto Test OK"; fi
+# Add the common build options
+CFLAGS+=-Wall -O0 -g -fno-strict-aliasing
+LDFLAGS+=-static
 
+%: %.c
+	$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $< -o $@ $(LDFLAGS)
 
-run-runcom: runcom
-	-$(QEMU) ./runcom $(SRC_PATH)/tests/pi_10.com
+all: $(TESTS)
 
-run-test_path: test_path
-	./test_path
+#
+# Test Runners
+#
+# By default we just run the test with the appropriate QEMU for the
+# target. More advanced tests may want to override the runner in their
+# specific make rules.
+#
 
-# rules to compile tests
+RUN_TESTS=$(patsubst %,run-%, $(TESTS))
 
-hello-i386: hello-i386.c
-	$(CC_I386) -nostdlib $(CFLAGS) -static $(LDFLAGS) -o $@ $<
-	strip $@
-
-# i386/x86_64 emulation test (test various opcodes) */
-test-i386: test-i386.c test-i386-code16.S test-i386-vm86.S \
-           test-i386.h test-i386-shift.h test-i386-muldiv.h
-	$(CC_I386) $(QEMU_INCLUDES) $(CFLAGS) $(LDFLAGS) -o $@ \
-              $(<D)/test-i386.c $(<D)/test-i386-code16.S $(<D)/test-i386-vm86.S -lm
-
-test-i386-fprem: test-i386-fprem.c
-	$(CC_I386) $(QEMU_INCLUDES) $(CFLAGS) $(LDFLAGS) -o $@ $^
-
-test-x86_64: test-i386.c \
-           test-i386.h test-i386-shift.h test-i386-muldiv.h
-	$(CC_X86_64) $(QEMU_INCLUDES) $(CFLAGS) $(LDFLAGS) -o $@ $(<D)/test-i386.c -lm
-
-# vm86 test
-runcom: runcom.c
-	$(CC_I386) $(CFLAGS) $(LDFLAGS) -o $@ $<
-
-# speed test
-sha1-i386: sha1.c
-	$(CC_I386) $(CFLAGS) $(LDFLAGS) -o $@ $<
-
-# arm test
-hello-arm: hello-arm.o
-	arm-linux-ld -o $@ $<
-
-hello-arm.o: hello-arm.c
-	arm-linux-gcc -Wall -g -O2 -c -o $@ $<
-
-test-arm-iwmmxt: test-arm-iwmmxt.s
-	cpp < $< | arm-linux-gnu-gcc -Wall -static -march=iwmmxt -mabi=aapcs -x assembler - -o $@
-
-# MIPS test
-hello-mips: hello-mips.c
-	mips-linux-gnu-gcc -nostdlib -static -mno-abicalls -fno-PIC -mabi=32 -Wall -Wextra -g -O2 -o $@ $<
-
-hello-mipsel: hello-mips.c
-	mipsel-linux-gnu-gcc -nostdlib -static -mno-abicalls -fno-PIC -mabi=32 -Wall -Wextra -g -O2 -o $@ $<
-
-# testsuite for the CRIS port.
-test-cris:
-	$(MAKE) -C cris check
+run-%: %
+	$(call quiet-command, $(QEMU) $< > $<.out, "TEST", "$< on $(TARGET_NAME)")
 
-# testsuite for the LM32 port.
-test-lm32:
-	$(MAKE) -C lm32 check
+.PHONY: run
+run: $(RUN_TESTS)
 
-clean:
-	rm -f *~ *.o test-i386.out test-i386.ref \
-           test-x86_64.log test-x86_64.ref qruncom $(TESTS)
+# There is no clean target, the calling make just rm's the tests build dir