On 28/06/2023 09:01, Tanmay Jagdale wrote:
Hi James,
On 23/06/2023 19:22, Tanmay Jagdale wrote:
The existing method of synthesizing instruction samples has the following issues:
- Non-branch instructions have mnemonics of branch instructions.
- Branch target address is missing.
Set the sample flags only when we reach the last instruction in the tidq (which would be a branch instruction) to solve issue 1).
To fix issue 2), start synthesizing the instructions from the previous packet (tidq->prev_packet) instead of current packet (tidq->packet). This way, it is easy to figure out the target address of the branch instruction in tidq->prev_packet which is the current packet's (tidq->packet) first executed instruction.
After the switch to processing the previous packet first, we no longer need to swap the packets during cs_etm__flush().
Hi Tanmay,
I think the fix for setting the right flags and instruction type makes sense, but is it possible to do it without the change to swapping in cs_etm__flush() or some of the other changes to cs_etm__synth_instruction_sample()?
Thanks for the review. I took this approach of swapping because it would be easy to figure out the target address of the branch. If we don't swap the packet synthesis, then we must decode the actual instruction to get the branch target address. IMHO, this would be a complex change.
Since the swapping approach is meant to solve issue 2) I will split the patch while posting the next version.
I'm seeing some differences in the output related to the PID that's assigned to a sample and some of the addresses that aren't explained by the commit message. Also there is no corresponding change to cs_etm__synth_branch_sample(), which is also using prev_packet etc so I'm wondering if that's correct now without the swap? That function gets used with the default itrace options or itrace=b
IMHO the existing way to handle itrace=b or itrace is correct and does not need any change since we are interested in only the last and first instruction from tidq->prev_packet and tidq->packet respectively, to generate the branching information.
For example if I run 'perf script --itrace=i100ns' and diff the output before and after your change I see a difference even though branch and instruction info isn't printed, so I wouldn't expect to see any changes. This is on a systemwide recording of a system under load.
Yes, the "tr start" mnemonic isn't printed in the flags column, but rest of columns are the same. Will fix this in the next version.
If you have observed any other differences, can you please share them ?
Also, can you please share the test case commands so that I can run them before submitting the next version ?
It's just if you diff any existing recording it seems that there are differences. In this case below I see a difference in the ordering of the samples generated. In a more complicated case with a VM running I also see a difference in which PID is assigned to some samples. It's probably not related to the VM but just that there was more going on on the machine.
It's not necessarily wrong, but we don't currently have any tests that verify the complete correctness of the decoding, so unless the commit message explains why there should be a difference we shouldn't make any changes.
stress -c 4 & sudo perf record -e cs_etm// -a -m,16M -- sleep 3
sudo perf-before-change script --itrace=i1000i > before sudo perf-after-change script --itrace=i1000i > after
diff before after
29d28 < stress 8198 [000] 1096.381602: 1000 instructions: aaaaceb70f2c rand@plt+0xc (/usr/bin/stress) 30a30
stress 8198 [000] 1096.381602: 1000
instructions: aaaaceb70f2c rand@plt+0xc (/usr/bin/stress) 193d192 < stress 8200 [001] 1096.381602: 1000 instructions: aaaaceb70f28 rand@plt+0x8 (/usr/bin/stress) 194a194
stress 8200 [001] 1096.381602: 1000
instructions: aaaaceb70f28 rand@plt+0x8 (/usr/bin/stress)
Thanks and regards, Tanmay
Thanks James
Signed-off-by: Tanmay Jagdale tanmay@marvell.com
tools/perf/util/cs-etm.c | 32 +++++++++++++++++++++++++------- 1 file changed, 25 insertions(+), 7 deletions(-)
diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 91299cc56bf7..446e00d98fd5 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -1418,10 +1418,26 @@ static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq, sample.stream_id = etmq->etm->instructions_id; sample.period = period; sample.cpu = tidq->packet->cpu;
sample.flags = tidq->prev_packet->flags; sample.cpumode = event->sample.header.misc;
cs_etm__copy_insn(etmq, tidq->trace_chan_id, tidq->packet, &sample);
cs_etm__copy_insn(etmq, tidq->trace_chan_id, tidq->prev_packet, &sample);
/* Populate branch target information only when we encounter
* branch instruction, which is at the end of tidq->prev_packet.*/if (addr == (tidq->prev_packet->end_addr - 4)) {
/* Update the perf_sample flags using the prev_packet* since that is the queue we are synthesizing.*/sample.flags = tidq->prev_packet->flags;/* The last instruction of the previous queue would be a* branch operation. Get the target of that branch by looking* into the first executed instruction of the current packet* queue.*/sample.addr = cs_etm__first_executed_instr(tidq->packet);}
if (etm->synth_opts.last_branch) sample.branch_stack = tidq->last_branch;
@@ -1641,7 +1657,7 @@ static int cs_etm__sample(struct cs_etm_queue *etmq, /* Get instructions remainder from previous packet */ instrs_prev = tidq->period_instructions;
- tidq->period_instructions += tidq->packet->instr_count;
tidq->period_instructions += tidq->prev_packet->instr_count;
/*
- Record a branch when the last instruction in
@@ -1721,8 +1737,11 @@ static int cs_etm__sample(struct cs_etm_queue *etmq, * been executed, but PC has not advanced to next * instruction) */
/* Get address from prev_packet since we are synthesizing* that in cs_etm__synth_instruction_sample()*/ addr = cs_etm__instr_addr(etmq, trace_chan_id,
tidq->packet, offset - 1);
tidq->prev_packet, offset - 1); ret = cs_etm__synth_instruction_sample( etmq, tidq, addr, etm->instructions_sample_period);@@ -1786,7 +1805,7 @@ static int cs_etm__flush(struct cs_etm_queue *etmq,
/* Handle start tracing packet */ if (tidq->prev_packet->sample_type == CS_ETM_EMPTY)
goto swap_packet;
goto reset_last_br;if (etmq->etm->synth_opts.last_branch && etmq->etm->synth_opts.instructions &&
@@ -1822,8 +1841,7 @@ static int cs_etm__flush(struct cs_etm_queue *etmq, return err; }
-swap_packet:
- cs_etm__packet_swap(etm, tidq);
+reset_last_br:
/* Reset last branches after flush the trace */ if (etm->synth_opts.last_branch)