Perf impact of sampling rate on performance - higher sample rates cost *less* overhead on NXP S32?

I am using perf in sampling mode to capture performance statistics of programs running on multi-core platform from NXP S32 platform running Linux 4.19.

E.g configuration

Core 0 - App0 , Core 1 - App1, Core 2 - App2

Without sampling i.e. at program level, App0 takes 6.9 seconds.

On sampling at 1Million cycles,App0 takes 6.3 sec

On sampling at 2Million cycles, App0 takes 6.4 sec

On sampling at 5Million cycles, App0 takes 6.5 sec

On sampling at 100Million cycles, App0 takes 6.8 sec.

As you can see with higher sampling period (100Million) App0 takes higher time to finish execution.

Actually I would have expected the opposite, i.e. sampling at 1Million cycles should have resulted in the program taking more time to execute due higher number of samples generated (perf overhead) as compared to 100 Million cycles?

I am unable to explain this behavior what do you think is causing this?

Any leads would be helpful.

P.S - On the Pi3B the behavior is as expected i.e sampling at 1million cycles results in longer execution time compared to 100 Million cycles.

UPDATE: I do not use perf from command line, instead make a perf system call using the perf event with the following flags in the struct perf_event_attr.

    struct perf_event_attr hw_event;
    pid_t pid = proccess_id;    // measure the current process/thread
    int cpu = -1;   // measure on any cpu
    unsigned long flags = 0;
    int fd_current;


    memset(&hw_event, 0, sizeof(struct perf_event_attr));
    hw_event.type = event_type;
    hw_event.size = sizeof(struct perf_event_attr);
    hw_event.config = event;
    if(group_fd == -1)
    {
        hw_event.sample_period = 2000000;
        hw_event.sample_type = PERF_SAMPLE_READ;
        hw_event.precise_ip = 1;
    }

    hw_event.disabled = 1;          // off by default. specifies whether the counter starts out disabled or enabled.
    hw_event.exclude_kernel = 0;    // excluding events that happen in the kernel-space
    hw_event.exclude_hv = 1;        // excluding events that happen in the hypervisor
    hw_event.pinned = pinned;       // specifies the counter to be on the CPU if at all possible. applies only to hardware counters and only to group leaders.
    hw_event.exclude_user = 0;      //  excludes events that happen in user space
    hw_event.exclude_callchain_kernel  = 0; // Do not include kernel callchains.
    hw_event.exclude_callchain_user = 0;    // Do not include user callchains.
    hw_event.read_format = PERF_FORMAT_GROUP; // Allows all counter values in an event group to be read with one read
    fd_current = syscall(__NR_perf_event_open, &hw_event, pid, cpu, group_fd, flags);
    if (fd_current == -1) {
      printf("Error opening leader %llx\n", hw_event.config);
      exit(EXIT_FAILURE);
    }

   return fd_current;