* [Qemu-devel] [RISU PATCH 1/9] risu: a bit more verbosity when running
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
@ 2016-12-02 15:59 ` Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 2/9] aarch64: add hand-coded risu skeleton for directed testing Alex Bennée
` (8 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Alex Bennée @ 2016-12-02 15:59 UTC (permalink / raw)
To: peter.maydell; +Cc: qemu-devel, joserz, Alex Bennée
Before this is could seem a little quite when running as you had no
indication stuff was happening (or how fast). I only dump on the master
side as I want to minimise the amount of qemu logs to sift through.
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
risu.c | 15 +++++++++++++--
risu.h | 3 +++
risu_aarch64.c | 3 +++
3 files changed, 19 insertions(+), 2 deletions(-)
diff --git a/risu.c b/risu.c
index 7e42160..756ca46 100644
--- a/risu.c
+++ b/risu.c
@@ -37,6 +37,16 @@ sigjmp_buf jmpbuf;
/* Should we test for FP exception status bits? */
int test_fp_exc = 0;
+long executed_tests = 0;
+void report_test_status(void *pc)
+{
+ executed_tests += 1;
+ if (executed_tests % 100 == 0) {
+ fprintf(stderr,"Executed %ld test instructions (pc=%p)\r",
+ executed_tests, pc);
+ }
+}
+
void master_sigill(int sig, siginfo_t *si, void *uc)
{
switch (recv_and_compare_register_info(master_socket, uc))
@@ -61,6 +71,7 @@ void apprentice_sigill(int sig, siginfo_t *si, void *uc)
return;
case 1:
/* end of test */
+ fprintf(stderr, "\nend of test\n");
exit(0);
default:
/* mismatch */
@@ -129,7 +140,7 @@ int master(int sock)
}
master_socket = sock;
set_sigill_handler(&master_sigill);
- fprintf(stderr, "starting image\n");
+ fprintf(stderr, "starting master image at 0x%lx\n", image_start_address);
image_start();
fprintf(stderr, "image returned unexpectedly\n");
exit(1);
@@ -139,7 +150,7 @@ int apprentice(int sock)
{
apprentice_socket = sock;
set_sigill_handler(&apprentice_sigill);
- fprintf(stderr, "starting image\n");
+ fprintf(stderr, "starting apprentice image at 0x%lx\n", image_start_address);
image_start();
fprintf(stderr, "image returned unexpectedly\n");
exit(1);
diff --git a/risu.h b/risu.h
index 26ed834..e4bb323 100644
--- a/risu.h
+++ b/risu.h
@@ -26,6 +26,7 @@ extern uintptr_t image_start_address;
extern void *memblock;
extern int test_fp_exc;
+extern int ismaster;
/* Ops code under test can request from risu: */
#define OP_COMPARE 0
@@ -59,6 +60,8 @@ int recv_and_compare_register_info(int sock, void *uc);
*/
int report_match_status(void);
+void report_test_status(void *pc);
+
/* Move the PC past this faulting insn by adjusting ucontext
*/
void advance_pc(void *uc);
diff --git a/risu_aarch64.c b/risu_aarch64.c
index 547f987..1595604 100644
--- a/risu_aarch64.c
+++ b/risu_aarch64.c
@@ -28,6 +28,9 @@ void advance_pc(void *vuc)
{
ucontext_t *uc = vuc;
uc->uc_mcontext.pc += 4;
+ if (ismaster) {
+ report_test_status((void *) uc->uc_mcontext.pc);
+ }
}
static void set_x0(void *vuc, uint64_t x0)
--
2.10.2
^ permalink raw reply related [flat|nested] 11+ messages in thread* [Qemu-devel] [RISU PATCH 2/9] aarch64: add hand-coded risu skeleton for directed testing
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 1/9] risu: a bit more verbosity when running Alex Bennée
@ 2016-12-02 15:59 ` Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 3/9] risu: add simple trace and replay support Alex Bennée
` (7 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Alex Bennée @ 2016-12-02 15:59 UTC (permalink / raw)
To: peter.maydell; +Cc: qemu-devel, joserz, Alex Bennée
Sometimes you want absolute control over your test set-up to feed
explicit values into the test. This started as an experiment but might
be useful for further developing tests.
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
Makefile | 7 ++
aarch64_simd_handcoded.risu.S | 208 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 215 insertions(+)
create mode 100644 aarch64_simd_handcoded.risu.S
diff --git a/Makefile b/Makefile
index bfa8cac..4202c35 100644
--- a/Makefile
+++ b/Makefile
@@ -36,6 +36,13 @@ $(PROG): $(OBJS)
%.risu.asm: %.risu.bin
${OBJDUMP} -b binary -m $(ARCH) -D $^ > $@
+# hand-coded tests
+%.risu.bin: %.risu.elf
+ $(OBJCOPY) -O binary $< $@
+
+%.risu.elf: %.risu.S
+ ${AS} -o $@ $^
+
%.o: %.c $(HDRS)
$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ -c $<
diff --git a/aarch64_simd_handcoded.risu.S b/aarch64_simd_handcoded.risu.S
new file mode 100644
index 0000000..61bd11a
--- /dev/null
+++ b/aarch64_simd_handcoded.risu.S
@@ -0,0 +1,208 @@
+/*
+ Hand coded RISU tests for aarch64
+
+ Sometimes you want slightly more than random instructions and you
+ want a specifically crafted test but within RISU's framework.
+
+ This file offers such a thing.
+ # So the last nibble indicates the desired operation:
+my $OP_COMPARE = 0; # compare registers
+my $OP_TESTEND = 1; # end of test, stop
+my $OP_SETMEMBLOCK = 2; # r0 is address of memory block (8192 bytes)
+my $OP_GETMEMBLOCK = 3; # add the address of memory block to r0
+my $OP_COMPAREMEM = 4; # compare memory block
+
+ */
+
+.macro risuop_comp
+ .word 0x00005af0
+.endm
+.macro risuop_testend
+ .word 0x00005af1
+.endm
+
+ .org 0x0
+
+//.globl .data
+ mov x0, #0x0 // #0
+ msr fpsr, x0
+ mov x0, #0x0 // #0
+ msr fpcr, x0
+ mrs x0, nzcv
+ eor w0, w0, #0xf0000000
+ msr nzcv, x0
+ adr x0, _q0
+ eor x0, x0, #0xf
+ b reg_setup
+
+ /*
+
+ This is the of block of data used for ld/st and setting up vector regs
+ Each .word is 32bits of data
+
+ */
+ .align 16
+
+_q0: .word 0x70000000, 0xffffffff, 0x80000000, 0xffffffff
+_q1: .word 0x90000000, 0x00000000, 0xa0000000, 0x00000000
+_q2: .word 0xffff0000, 0x00000000, 0xeeee0000, 0x00000000
+_q3: .word 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
+_q4: .word 0x80000000, 0x00000000, 0xf0000000, 0x00000000
+_q5: .word 0xffff0000, 0x00000000, 0xeeee0000, 0x00000000
+_q6: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q7: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+
+_q8: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q9: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q10: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q11: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q12: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q13: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q14: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q15: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+
+_q16: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q17: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q18: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q19: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q20: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q21: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q22: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q23: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+
+_q24: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q25: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q26: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q27: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q28: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q29: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q30: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q31: .word 0x00000000, 0x00000000, 0x00000000, 0x00000000
+
+ .align 16
+
+ /* Setup the register state */
+reg_setup:
+ ldp q0, q1, [x0],#32
+ ldp q2, q3, [x0],#16
+ ldp q4, q5, [x0],#16
+ ldp q6, q7, [x0],#16
+ ldp q8, q9, [x0],#16
+ ldp q10, q11, [x0],#16
+ ldp q12, q13, [x0],#16
+ ldp q14, q15, [x0],#16
+ ldp q16, q17, [x0],#16
+ ldp q18, q19, [x0],#16
+ ldp q20, q21, [x0],#16
+ ldp q22, q23, [x0],#16
+ ldp q24, q25, [x0],#16
+ ldp q26, q27, [x0],#16
+ ldp q28, q29, [x0],#16
+ ldp q30, q31, [x0],#16
+
+ /* Set-up integer registers */
+ mov x0, #0
+ mov x1, #0
+ mov x2, #0
+ mov x3, #0
+ mov x4, #0
+ mov x5, #0
+ mov x6, #0
+ mov x7, #0
+ mov x8, #0
+ mov x9, #0
+ mov x10, #0
+ mov x11, #0
+ mov x12, #0
+ mov x13, #0
+ mov x14, #0
+ mov x15, #0
+ mov x16, #0
+ mov x17, #0
+ mov x18, #0
+ mov x19, #0
+ mov x20, #0
+ mov x21, #0
+ mov x22, #0
+ mov x23, #0
+ mov x24, #0
+ mov x25, #0
+ mov x26, #0
+ mov x26, #0
+ mov x27, #0
+ mov x28, #0
+ mov x29, #0
+ mov x30, #0
+
+ risuop_comp
+
+ /* Testing ursra */
+
+ ursra v16.2d, v0.2d, #64
+ risuop_comp
+ ursra v17.2d, v1.2d, #64
+ risuop_comp
+ ursra v18.2d, v2.2d, #64
+ risuop_comp
+ ursra v19.2d, v3.2d, #64
+ risuop_comp
+ ursra v20.2d, v4.2d, #64
+ risuop_comp
+ ursra v21.2d, v5.2d, #64
+ risuop_comp
+ ursra v22.2d, v6.2d, #64
+ risuop_comp
+ ursra v23.2d, v7.2d, #64
+ risuop_comp
+ ursra v24.2d, v8.2d, #64
+ risuop_comp
+ ursra v25.2d, v9.2d, #64
+ risuop_comp
+ ursra v26.2d, v10.2d, #64
+ risuop_comp
+ ursra v27.2d, v11.2d, #64
+ risuop_comp
+ ursra v28.2d, v12.2d, #64
+ risuop_comp
+ ursra v29.2d, v13.2d, #64
+ risuop_comp
+ ursra v30.2d, v14.2d, #64
+ risuop_comp
+ ursra v31.2d, v15.2d, #64
+ risuop_comp
+
+ /* second pass */
+ ursra v16.2d, v0.2d, #64
+ risuop_comp
+ ursra v17.2d, v1.2d, #64
+ risuop_comp
+ ursra v18.2d, v2.2d, #64
+ risuop_comp
+ ursra v19.2d, v3.2d, #64
+ risuop_comp
+ ursra v20.2d, v4.2d, #64
+ risuop_comp
+ ursra v21.2d, v5.2d, #64
+ risuop_comp
+ ursra v22.2d, v6.2d, #64
+ risuop_comp
+ ursra v23.2d, v7.2d, #64
+ risuop_comp
+ ursra v24.2d, v8.2d, #64
+ risuop_comp
+ ursra v25.2d, v9.2d, #64
+ risuop_comp
+ ursra v26.2d, v10.2d, #64
+ risuop_comp
+ ursra v27.2d, v11.2d, #64
+ risuop_comp
+ ursra v28.2d, v12.2d, #64
+ risuop_comp
+ ursra v29.2d, v13.2d, #64
+ risuop_comp
+ ursra v30.2d, v14.2d, #64
+ risuop_comp
+ ursra v31.2d, v15.2d, #64
+ risuop_comp
+
+ risuop_testend /* test end */
--
2.10.2
^ permalink raw reply related [flat|nested] 11+ messages in thread* [Qemu-devel] [RISU PATCH 3/9] risu: add simple trace and replay support
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 1/9] risu: a bit more verbosity when running Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 2/9] aarch64: add hand-coded risu skeleton for directed testing Alex Bennée
@ 2016-12-02 15:59 ` Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 4/9] risu: add support compressed tracefiles Alex Bennée
` (6 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Alex Bennée @ 2016-12-02 15:59 UTC (permalink / raw)
To: peter.maydell; +Cc: qemu-devel, joserz, Alex Bennée
This adds a very dumb and easily breakable trace and replay support to
the aarch64 build of risu. In --master mode the various risu ops trigger
a write of register/memory state into a binary file which can be played
back to an apprentice. Currently there is no validation of the image
source so feeding the wrong image will fail straight away.
The trace files will get very big for any appreciable sized test file
and this will be addressed in later patches.
There is an inevitable amount of copy&paste between the trace file and
socket based code. Ideally it would be nice to have as much of this as
common as possible and reduce the re-implementation between the various
backends.
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
v2
- moved read/write functions into main risu.c
- cleaned up formatting
- report more in apprentice --trace mode
v3
- fix options parsing
---
risu.c | 104 +++++++++++++++++++++++++++++++++++++------------
risu.h | 12 ++++++
risu_aarch64.c | 90 ++++++++++++++++++++++++++++++++++++++++--
risu_reginfo_aarch64.h | 7 ++++
4 files changed, 185 insertions(+), 28 deletions(-)
diff --git a/risu.c b/risu.c
index 756ca46..f36b4c6 100644
--- a/risu.c
+++ b/risu.c
@@ -31,6 +31,7 @@
void *memblock = 0;
int apprentice_socket, master_socket;
+int trace_file = 0;
sigjmp_buf jmpbuf;
@@ -40,31 +41,57 @@ int test_fp_exc = 0;
long executed_tests = 0;
void report_test_status(void *pc)
{
- executed_tests += 1;
- if (executed_tests % 100 == 0) {
- fprintf(stderr,"Executed %ld test instructions (pc=%p)\r",
- executed_tests, pc);
+ if (ismaster || trace_file) {
+ executed_tests += 1;
+ if (executed_tests % 100 == 0) {
+ fprintf(stderr,"Executed %ld test instructions (pc=%p)\r",
+ executed_tests, pc);
+ }
}
}
+int write_trace(void *ptr, size_t bytes)
+{
+ size_t res = write(trace_file, ptr, bytes);
+ return res == bytes;
+}
+
+int read_trace(void *ptr, size_t bytes)
+{
+ size_t res = read(trace_file, ptr, bytes);
+ return res == bytes;
+}
+
void master_sigill(int sig, siginfo_t *si, void *uc)
{
- switch (recv_and_compare_register_info(master_socket, uc))
- {
- case 0:
- /* match OK */
- advance_pc(uc);
- return;
- default:
- /* mismatch, or end of test */
- siglongjmp(jmpbuf, 1);
+ if (trace_file) {
+ if (write_to_tracefile(write_trace, uc)!=0) {
+ /* end of test */
+ siglongjmp(jmpbuf, 1);
+ /* never */
+ return;
+ }
+ } else {
+ if (recv_and_compare_register_info(master_socket, uc)!=0) {
+ /* mismatch, or end of test */
+ siglongjmp(jmpbuf, 1);
+ /* never */
+ return;
+ }
}
+ advance_pc(uc);
}
void apprentice_sigill(int sig, siginfo_t *si, void *uc)
{
- switch (send_register_info(apprentice_socket, uc))
- {
+ int resp;
+ if (trace_file) {
+ resp = read_tracefile_and_check(read_trace, uc);
+ } else {
+ resp = send_register_info(apprentice_socket, uc);
+ }
+ switch (resp)
+ {
case 0:
/* match OK */
advance_pc(uc);
@@ -75,6 +102,9 @@ void apprentice_sigill(int sig, siginfo_t *si, void *uc)
exit(0);
default:
/* mismatch */
+ if (trace_file) {
+ report_match_status();
+ }
exit(1);
}
}
@@ -136,7 +166,13 @@ int master(int sock)
{
if (sigsetjmp(jmpbuf, 1))
{
- return report_match_status();
+ if (trace_file) {
+ close(trace_file);
+ fprintf(stderr,"Done...\n");
+ return 0;
+ } else {
+ return report_match_status();
+ }
}
master_socket = sock;
set_sigill_handler(&master_sigill);
@@ -165,6 +201,7 @@ void usage (void)
fprintf(stderr, "between master and apprentice risu processes.\n\n");
fprintf(stderr, "Options:\n");
fprintf(stderr, " --master Be the master (server)\n");
+ fprintf(stderr, " -t, --trace=FILE Record/playback trace file\n");
fprintf(stderr, " -h, --host=HOST Specify master host machine (apprentice only)\n");
fprintf(stderr, " -p, --port=PORT Specify the port to connect to/listen on (default 9191)\n");
}
@@ -175,6 +212,7 @@ int main(int argc, char **argv)
uint16_t port = 9191;
char *hostname = "localhost";
char *imgfile;
+ char *trace_fn = NULL;
int sock;
// TODO clean this up later
@@ -185,13 +223,14 @@ int main(int argc, char **argv)
{
{ "help", no_argument, 0, '?'},
{ "master", no_argument, &ismaster, 1 },
+ { "trace", required_argument, 0, 't' },
{ "host", required_argument, 0, 'h' },
{ "port", required_argument, 0, 'p' },
{ "test-fp-exc", no_argument, &test_fp_exc, 1 },
{ 0,0,0,0 }
};
int optidx = 0;
- int c = getopt_long(argc, argv, "h:p:", longopts, &optidx);
+ int c = getopt_long(argc, argv, "h:p:t:", longopts, &optidx);
if (c == -1)
{
break;
@@ -204,6 +243,11 @@ int main(int argc, char **argv)
/* flag set by getopt_long, do nothing */
break;
}
+ case 't':
+ {
+ trace_fn = optarg;
+ break;
+ }
case 'h':
{
hostname = optarg;
@@ -234,18 +278,28 @@ int main(int argc, char **argv)
}
load_image(imgfile);
-
+
if (ismaster)
{
- fprintf(stderr, "master port %d\n", port);
- sock = master_connect(port);
- return master(sock);
+ if (trace_fn)
+ {
+ trace_file = open(trace_fn, O_WRONLY|O_CREAT, S_IRWXU);
+ } else {
+ fprintf(stderr, "master port %d\n", port);
+ sock = master_connect(port);
+ }
+ return master(sock);
}
else
- {
- fprintf(stderr, "apprentice host %s port %d\n", hostname, port);
- sock = apprentice_connect(hostname, port);
- return apprentice(sock);
+ {
+ if (trace_fn)
+ {
+ trace_file = open(trace_fn, O_RDONLY);
+ } else {
+ fprintf(stderr, "apprentice host %s port %d\n", hostname, port);
+ sock = apprentice_connect(hostname, port);
+ }
+ return apprentice(sock);
}
}
diff --git a/risu.h b/risu.h
index e4bb323..57161f2 100644
--- a/risu.h
+++ b/risu.h
@@ -52,6 +52,18 @@ int send_register_info(int sock, void *uc);
*/
int recv_and_compare_register_info(int sock, void *uc);
+/* To keep the read/write logic from multiplying across all arches
+ * we wrap up the function here to keep all the changes in one place
+ */
+typedef int (*trace_write_fn) (void *ptr, size_t bytes);
+typedef int (*trace_read_fn) (void *ptr, size_t bytes);
+
+/* Write out to trace file */
+int write_to_tracefile(trace_write_fn write_fn, void *uc);
+
+/* Read from trace file and check */
+int read_tracefile_and_check(trace_read_fn read_fn, void * uc);
+
/* Print a useful report on the status of the last comparison
* done in recv_and_compare_register_info(). This is called on
* exit, so need not restrict itself to signal-safe functions.
diff --git a/risu_aarch64.c b/risu_aarch64.c
index 1595604..9d538cb 100644
--- a/risu_aarch64.c
+++ b/risu_aarch64.c
@@ -13,6 +13,7 @@
#include <stdio.h>
#include <ucontext.h>
#include <string.h>
+#include <unistd.h>
#include "risu.h"
#include "risu_reginfo_aarch64.h"
@@ -28,9 +29,7 @@ void advance_pc(void *vuc)
{
ucontext_t *uc = vuc;
uc->uc_mcontext.pc += 4;
- if (ismaster) {
- report_test_status((void *) uc->uc_mcontext.pc);
- }
+ report_test_status((void *) uc->uc_mcontext.pc);
}
static void set_x0(void *vuc, uint64_t x0)
@@ -135,6 +134,91 @@ int recv_and_compare_register_info(int sock, void *uc)
return resp;
}
+int write_to_tracefile(trace_write_fn write_fn, void *uc)
+{
+ int resp = 0, op;
+ trace_header_t header;
+
+ reginfo_init(&master_ri, uc);
+ op = get_risuop(master_ri.faulting_insn);
+ header.pc = master_ri.pc;
+ header.risu_op = op;
+ write_fn(&header, sizeof(header));
+
+ switch (op) {
+ case OP_TESTEND:
+ resp = 1;
+ case OP_COMPARE:
+ default:
+ write_fn(&master_ri, sizeof(master_ri));
+ break;
+ case OP_SETMEMBLOCK:
+ memblock = (void *)master_ri.regs[0];
+ break;
+ case OP_GETMEMBLOCK:
+ set_x0(uc, master_ri.regs[0] + (uintptr_t)memblock);
+ break;
+ case OP_COMPAREMEM:
+ write_fn(memblock, MEMBLOCKLEN);
+ break;
+ }
+
+ return resp;
+}
+
+
+int read_tracefile_and_check(trace_read_fn read_fn, void * uc)
+{
+ int resp = 0, op;
+ trace_header_t header;
+
+ reginfo_init(&master_ri, uc);
+ op = get_risuop(master_ri.faulting_insn);
+
+ read_fn(&header, sizeof(header));
+ if ( header.pc == master_ri.pc &&
+ header.risu_op == op )
+ {
+ switch (op) {
+ case OP_COMPARE:
+ case OP_TESTEND:
+ default:
+ if (!read_fn(&apprentice_ri, sizeof(apprentice_ri))) {
+ packet_mismatch = 1;
+ resp = 2;
+ } else if (!reginfo_is_eq(&master_ri, &apprentice_ri)) {
+ /* register mismatch */
+ resp = 2;
+ } else if (op == OP_TESTEND) {
+ resp = 1;
+ }
+ break;
+ case OP_SETMEMBLOCK:
+ memblock = (void *)master_ri.regs[0];
+ break;
+ case OP_GETMEMBLOCK:
+ set_x0(uc, master_ri.regs[0] + (uintptr_t)memblock);
+ break;
+ case OP_COMPAREMEM:
+ mem_used = 1;
+ if (!read_fn(apprentice_memblock, MEMBLOCKLEN)) {
+ packet_mismatch = 1;
+ resp = 2;
+ } else if (memcmp(memblock, apprentice_memblock, MEMBLOCKLEN) != 0) {
+ /* memory mismatch */
+ resp = 2;
+ }
+ break;
+ }
+ } else {
+ fprintf(stderr, "out of sync %lx/%lx %d/%d\n",
+ master_ri.pc, header.pc,
+ op, header.risu_op);
+ resp = 2;
+ }
+ return resp;
+}
+
/* Print a useful report on the status of the last comparison
* done in recv_and_compare_register_info(). This is called on
* exit, so need not restrict itself to signal-safe functions.
diff --git a/risu_reginfo_aarch64.h b/risu_reginfo_aarch64.h
index 166b76c..db51cb2 100644
--- a/risu_reginfo_aarch64.h
+++ b/risu_reginfo_aarch64.h
@@ -28,6 +28,13 @@ struct reginfo
__uint128_t vregs[32];
};
+typedef struct
+{
+ uint64_t pc;
+ uint32_t risu_op;
+} trace_header_t;
+
+
/* initialize structure from a ucontext */
void reginfo_init(struct reginfo *ri, ucontext_t *uc);
--
2.10.2
^ permalink raw reply related [flat|nested] 11+ messages in thread* [Qemu-devel] [RISU PATCH 4/9] risu: add support compressed tracefiles
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
` (2 preceding siblings ...)
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 3/9] risu: add simple trace and replay support Alex Bennée
@ 2016-12-02 15:59 ` Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 5/9] risu_aarch64: it's -> it is Alex Bennée
` (5 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Alex Bennée @ 2016-12-02 15:59 UTC (permalink / raw)
To: peter.maydell; +Cc: qemu-devel, joserz, Alex Bennée
This uses the magic of zlib's gzread/write interface to wrap the
tracefile in compression. The code changes are tiny. I spent more time
messing about with the configure/linker stuff to auto-detect bits.
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
Makefile | 3 ++-
configure | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
risu.c | 13 +++++++++----
3 files changed, 66 insertions(+), 5 deletions(-)
diff --git a/Makefile b/Makefile
index 4202c35..4a2ef02 100644
--- a/Makefile
+++ b/Makefile
@@ -14,6 +14,7 @@
include Makefile.in
CFLAGS ?= -g -Wall
+LDFLAGS += -lz
PROG=risu
SRCS=risu.c comms.c risu_$(ARCH).c risu_reginfo_$(ARCH).c
@@ -31,7 +32,7 @@ all: $(PROG) $(BINS)
dump: $(RISU_ASMS)
$(PROG): $(OBJS)
- $(CC) $(STATIC) $(CFLAGS) -o $@ $^
+ $(CC) $(STATIC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
%.risu.asm: %.risu.bin
${OBJDUMP} -b binary -m $(ARCH) -D $^ > $@
diff --git a/configure b/configure
index f81bdb5..d11680f 100755
--- a/configure
+++ b/configure
@@ -6,6 +6,10 @@ compile() {
$CC $CFLAGS -c -o ${1}.o ${1}.c 2>/dev/null
}
+link() {
+ $LD $LDFLAGS -l${2} -o ${1} ${1}.o 2>/dev/null
+}
+
check_define() {
c=${tmp_dir}/check_define_${1}
cat > ${c}.c <<EOF
@@ -34,6 +38,50 @@ guess_arch() {
fi
}
+check_type() {
+ c=${tmp_dir}/check_type_${1}
+ cat > ${c}.c <<EOF
+#include <inttypes.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+int main(void) { $1 thisone; return 0; }
+EOF
+ compile $c
+}
+
+check_lib() {
+ c=${tmp_dir}/check_lib${1}
+ cat > ${c}.c <<EOF
+#include <stdint.h>
+#include <$2.h>
+
+int main(void) { $3; return 0; }
+EOF
+ compile $c && link $c $1
+}
+
+generate_config() {
+ cfg=config.h
+ echo "generating config.h..."
+
+ echo "/* config.h - generated by the 'configure' script */" > $cfg
+ echo "#ifndef CONFIG_H" >> $cfg
+ echo "#define CONFIG_H 1" >> $cfg
+
+ if check_type uintptr_t ; then
+ echo "#define HAVE_UINTPTR_T 1" >> $cfg
+ fi
+ if check_type socklen_t ; then
+ echo "#define HAVE_SOCKLEN_T 1" >> $cfg
+ fi
+
+ echo "#endif /* CONFIG_H */" >> $cfg
+
+ echo "...done"
+}
+
generate_makefilein() {
m=Makefile.in
echo "generating Makefile.in..."
@@ -93,6 +141,7 @@ done
CC="${CC-${CROSS_PREFIX}gcc}"
AS="${AS-${CROSS_PREFIX}as}"
+LD="${LD-${CROSS_PREFIX}ld}"
OBJCOPY="${OBJCOPY-${CROSS_PREFIX}objcopy}"
OBJDUMP="${OBJDUMP-${CROSS_PREFIX}objdump}"
@@ -100,6 +149,12 @@ if test "x${ARCH}" = "x"; then
guess_arch
fi
+if ! check_lib z zlib "zlibVersion()"; then
+ echo "Cannot find libz compression library"
+ exit 1
+fi
+
+generate_config
generate_makefilein
echo "type 'make' to start the build"
diff --git a/risu.c b/risu.c
index f36b4c6..1d58d4f 100644
--- a/risu.c
+++ b/risu.c
@@ -25,6 +25,7 @@
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
+#include <zlib.h>
#include "risu.h"
@@ -32,6 +33,7 @@ void *memblock = 0;
int apprentice_socket, master_socket;
int trace_file = 0;
+gzFile gz_trace_file;
sigjmp_buf jmpbuf;
@@ -52,13 +54,13 @@ void report_test_status(void *pc)
int write_trace(void *ptr, size_t bytes)
{
- size_t res = write(trace_file, ptr, bytes);
+ size_t res = gzwrite(gz_trace_file, ptr, bytes);
return res == bytes;
}
int read_trace(void *ptr, size_t bytes)
{
- size_t res = read(trace_file, ptr, bytes);
+ size_t res = gzread(gz_trace_file, ptr, bytes);
return res == bytes;
}
@@ -166,8 +168,9 @@ int master(int sock)
{
if (sigsetjmp(jmpbuf, 1))
{
- if (trace_file) {
- close(trace_file);
+ if (trace_file)
+ {
+ gzclose(gz_trace_file);
fprintf(stderr,"Done...\n");
return 0;
} else {
@@ -284,6 +287,7 @@ int main(int argc, char **argv)
if (trace_fn)
{
trace_file = open(trace_fn, O_WRONLY|O_CREAT, S_IRWXU);
+ gz_trace_file = gzdopen(trace_file, "wb9");
} else {
fprintf(stderr, "master port %d\n", port);
sock = master_connect(port);
@@ -295,6 +299,7 @@ int main(int argc, char **argv)
if (trace_fn)
{
trace_file = open(trace_fn, O_RDONLY);
+ gz_trace_file = gzdopen(trace_file, "rb");
} else {
fprintf(stderr, "apprentice host %s port %d\n", hostname, port);
sock = apprentice_connect(hostname, port);
--
2.10.2
^ permalink raw reply related [flat|nested] 11+ messages in thread* [Qemu-devel] [RISU PATCH 5/9] risu_aarch64: it's -> it is
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
` (3 preceding siblings ...)
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 4/9] risu: add support compressed tracefiles Alex Bennée
@ 2016-12-02 15:59 ` Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 6/9] risugen: remove grocer's apostrophe from REs Alex Bennée
` (4 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Alex Bennée @ 2016-12-02 15:59 UTC (permalink / raw)
To: peter.maydell; +Cc: qemu-devel, joserz, Alex Bennée
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
risu_aarch64.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/risu_aarch64.c b/risu_aarch64.c
index 9d538cb..77f9288 100644
--- a/risu_aarch64.c
+++ b/risu_aarch64.c
@@ -82,7 +82,7 @@ int send_register_info(int sock, void *uc)
* NB: called from a signal handler.
*
* We don't have any kind of identifying info in the incoming data
- * that says whether it's register or memory data, so if the two
+ * that says whether it is register or memory data, so if the two
* sides get out of sync then we will fail obscurely.
*/
int recv_and_compare_register_info(int sock, void *uc)
--
2.10.2
^ permalink raw reply related [flat|nested] 11+ messages in thread* [Qemu-devel] [RISU PATCH 6/9] risugen: remove grocer's apostrophe from REs
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
` (4 preceding siblings ...)
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 5/9] risu_aarch64: it's -> it is Alex Bennée
@ 2016-12-02 15:59 ` Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 7/9] new: generate_all.sh script Alex Bennée
` (3 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Alex Bennée @ 2016-12-02 15:59 UTC (permalink / raw)
To: peter.maydell; +Cc: qemu-devel, joserz, Alex Bennée
This also fixes perl-modes confusion about escaped strings.
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
risugen | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/risugen b/risugen
index a604fe5..77a550b 100755
--- a/risugen
+++ b/risugen
@@ -288,7 +288,7 @@ Valid options:
'VMULL' will match 'VMULL A1' and 'VMULL A2' but not
'VMULL_scalar A1'. This is generally what you wanted.
--not-pattern re[,re...] : exclude patterns matching regular expression.
- These RE's are applied after the matching pattern which
+ These REs are applied after the matching pattern which
is useful if you want to exclude a specific instruction from
a general set you have excluded.
--no-fp : disable floating point: no fp init, randomization etc.
--
2.10.2
^ permalink raw reply related [flat|nested] 11+ messages in thread* [Qemu-devel] [RISU PATCH 7/9] new: generate_all.sh script
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
` (5 preceding siblings ...)
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 6/9] risugen: remove grocer's apostrophe from REs Alex Bennée
@ 2016-12-02 15:59 ` Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 8/9] new: record_traces.sh helper script Alex Bennée
` (2 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Alex Bennée @ 2016-12-02 15:59 UTC (permalink / raw)
To: peter.maydell; +Cc: qemu-devel, joserz, Alex Bennée
A simple script to cut up a full .risu file and generate binaries for
the whole set. Call with risu file and instruction count and directory:
./generate_all.sh aarch64.risu 4 20000 testcases.aarch64
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
generate_all.sh | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 55 insertions(+)
create mode 100755 generate_all.sh
diff --git a/generate_all.sh b/generate_all.sh
new file mode 100755
index 0000000..4c490be
--- /dev/null
+++ b/generate_all.sh
@@ -0,0 +1,55 @@
+#!/bin/sh
+#
+# Generate All Patterns
+#
+# Work through a given .risu file and generate full coverage
+#
+
+BASE_SHELL_PARAMS="./risugen"
+
+risufile=$1
+divisor=$2
+insns=$3
+dir=$4
+
+if test -z "$risufile"; then
+ echo "Need to specify a risu defintiion file"
+ exit 1
+fi
+
+if test -z "$divisor"; then
+ divisor=4
+fi
+
+if test -n "$insns"; then
+ BASE_SHELL_PARAMS="${BASE_SHELL_PARAMS} --numinsns $insns"
+fi
+
+if test -n "dir"; then
+ mkdir -p $dir
+else
+ dir="./"
+fi
+
+ALL_INSNS=$(cat $risufile | ag "^\w" | cut -f 1 -d " " | sort)
+COUNT=$(cat $risufile | ag "^\w" | cut -f 1 -d " " | wc -l)
+set -- $ALL_INSNS
+
+GROUP=$((COUNT / $divisor))
+
+while test $# -gt 0 ; do
+ INSN_PATTERNS=""
+ I_FILE="$dir/insn_"
+ for i in `seq 1 $divisor`; do
+ I=$1
+ if test -n "${I}"; then
+ shift
+ INSN_PATTERNS="${INSN_PATTERNS} --pattern ${I}"
+ I_FILE="${I_FILE}${I}_"
+ fi
+ done
+ I_FILE="${I_FILE}_INC.risu.bin"
+ CMD="$BASE_SHELL_PARAMS ${INSN_PATTERNS} $risufile ${I_FILE}"
+ echo "Running: $CMD"
+ $CMD
+done
--
2.10.2
^ permalink raw reply related [flat|nested] 11+ messages in thread* [Qemu-devel] [RISU PATCH 8/9] new: record_traces.sh helper script
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
` (6 preceding siblings ...)
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 7/9] new: generate_all.sh script Alex Bennée
@ 2016-12-02 15:59 ` Alex Bennée
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 9/9] new: run_risu.sh script Alex Bennée
2016-12-05 9:50 ` [Qemu-devel] [RISU PATCH 0/9] Record/playback patches joserz
9 siblings, 0 replies; 11+ messages in thread
From: Alex Bennée @ 2016-12-02 15:59 UTC (permalink / raw)
To: peter.maydell; +Cc: qemu-devel, joserz, Alex Bennée
A simple script to run through a bunch of binaries and generate their
trace files.
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
record_traces.sh | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
create mode 100755 record_traces.sh
diff --git a/record_traces.sh b/record_traces.sh
new file mode 100755
index 0000000..89c62d5
--- /dev/null
+++ b/record_traces.sh
@@ -0,0 +1,16 @@
+#!/bin/sh
+#
+# Record traces
+#
+# A risu helper script to batch process a bunch of binaries and record their outputs
+#
+set -e
+
+
+for f in $@; do
+ echo "Running risu against $f"
+ t="$f.trace"
+ ./risu --master $f -t $t
+ echo "Checking trace file OK"
+ ./risu $f -t $t
+done
--
2.10.2
^ permalink raw reply related [flat|nested] 11+ messages in thread* [Qemu-devel] [RISU PATCH 9/9] new: run_risu.sh script
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
` (7 preceding siblings ...)
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 8/9] new: record_traces.sh helper script Alex Bennée
@ 2016-12-02 15:59 ` Alex Bennée
2016-12-05 9:50 ` [Qemu-devel] [RISU PATCH 0/9] Record/playback patches joserz
9 siblings, 0 replies; 11+ messages in thread
From: Alex Bennée @ 2016-12-02 15:59 UTC (permalink / raw)
To: peter.maydell; +Cc: qemu-devel, joserz, Alex Bennée
A simple script to work through running all of a bunch of files with
record/playback traces. Dumps a summary and the number of failed tests
at the end.
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
run_risu.sh | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 51 insertions(+)
create mode 100755 run_risu.sh
diff --git a/run_risu.sh b/run_risu.sh
new file mode 100755
index 0000000..8a91e1a
--- /dev/null
+++ b/run_risu.sh
@@ -0,0 +1,51 @@
+#!/bin/bash
+#
+# Run risu against a set of binaries + trace files
+#
+#
+#set -e
+
+passed=()
+failed=()
+missing=()
+
+script_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd -P)
+risu_path=${script_dir}/risu
+
+for f in $@; do
+ t="$f.trace"
+ echo "Running $f against $t"
+ if [ -e $t ]; then
+ ${QEMU} ${risu_path} $f -t $t
+ if [ $? == 0 ]; then
+ passed=( "${passed[@]}" $f )
+ else
+ failed=( "${failed[@]}" $f )
+ fi
+ else
+ missing=( "${missing[@]}" $f )
+ fi
+done
+
+if test ${#missing[@]} -gt 0; then
+ echo "Tests missing ${#missing[@]} trace files:"
+ for m in "${missing[@]}"; do
+ echo "$m"
+ done
+fi
+
+if test ${#passed[@]} -gt 0; then
+ echo "Passed ${#passed[@]} tests:"
+ for p in "${passed[@]}"; do
+ echo "$p"
+ done
+fi
+
+if test ${#failed[@]} -gt 0; then
+ echo "Failed ${#failed[@]} tests:"
+ for f in "${failed[@]}"; do
+ echo "$f"
+ done
+fi
+
+exit ${#failed[@]}
--
2.10.2
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [Qemu-devel] [RISU PATCH 0/9] Record/playback patches
2016-12-02 15:59 [Qemu-devel] [RISU PATCH 0/9] Record/playback patches Alex Bennée
` (8 preceding siblings ...)
2016-12-02 15:59 ` [Qemu-devel] [RISU PATCH 9/9] new: run_risu.sh script Alex Bennée
@ 2016-12-05 9:50 ` joserz
9 siblings, 0 replies; 11+ messages in thread
From: joserz @ 2016-12-05 9:50 UTC (permalink / raw)
To: Alex Bennée; +Cc: peter.maydell, qemu-devel
On Fri, Dec 02, 2016 at 03:59:26PM +0000, Alex Bennée wrote:
> Hi Peter,
>
> I've been cleaning things up so I thought I should re-post my current
> state. These all apply to the current master.
>
> I had to regenerate all the risu binaries as I'd used --no-fp for a
> bunch of them originally which was causing failures. I'm not sure if
> this is due to the FP registers not being cleared by the kernel if FP
> isn't used - but we certainly don't do anything to them except when
> set by the memory/context blocks (without --no-fp). This led me to
> write the 3 noddy scripts included here.
>
> The record/playback is still aarch64 only. I'm open to ideas to do
> this more cleanly otherwise if anyone has access to some PPC hardware
> I can port the record/playback code to the other architectures.
Excellent job, Alex
I can make the PPC port here. I still have work to do in Risu for PPC so
I can include this in my task as well. I'm planning to start working on
it this week.
Thank you
>
> Feel free to cherry-pick any of the minor patches as you wish ;-)
>
> Alex Bennée (9):
> risu: a bit more verbosity when running
> aarch64: add hand-coded risu skeleton for directed testing
> risu: add simple trace and replay support
> risu: add support compressed tracefiles
> risu_aarch64: it's -> it is
> risugen: remove grocer's apostrophe from REs
> new: generate_all.sh script
> new: record_traces.sh helper script
> new: run_risu.sh script
>
> Makefile | 10 +-
> aarch64_simd_handcoded.risu.S | 208 ++++++++++++++++++++++++++++++++++++++++++
> configure | 55 +++++++++++
> generate_all.sh | 55 +++++++++++
> record_traces.sh | 16 ++++
> risu.c | 116 ++++++++++++++++++-----
> risu.h | 15 +++
> risu_aarch64.c | 89 +++++++++++++++++-
> risu_reginfo_aarch64.h | 7 ++
> risugen | 2 +-
> run_risu.sh | 51 +++++++++++
> 11 files changed, 598 insertions(+), 26 deletions(-)
> create mode 100644 aarch64_simd_handcoded.risu.S
> create mode 100755 generate_all.sh
> create mode 100755 record_traces.sh
> create mode 100755 run_risu.sh
>
> --
> 2.10.2
>
^ permalink raw reply [flat|nested] 11+ messages in thread