From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-yb1-f178.google.com (mail-yb1-f178.google.com [209.85.219.178]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 101D114885E for ; Fri, 19 Jul 2024 22:25:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.219.178 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1721427960; cv=none; b=lKI+wo1++D6L2qblC6hc4XUaFEAKFc+vOwKXd21ApfhSQowuap/rMEXjtHMNI9MndKUuuhZwC1p5dFtJvwBfRDWoyRG0gT4myZjtRzcCS6kbg/iDdVnFfRTN/d8fjQZo5JesTRgVozBEvvadWXaW9yHqpKkuJNgHrij3nCR5n0M= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1721427960; c=relaxed/simple; bh=V+A0QoX/sjgq3hKDLdx0jDhCzlSl3I7HNGE9OamCluM=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=NsO0VzpRrQ6cqyTSluADoPL0y7nEZg3zipeMt2vLEzP49ENFC4pfAjmLxR0SJXchue4znbviy8mWSzfPXN9ZDNw/1GCsxmP7L5xJA7V+bRJb1CLL3VaVSik3ggD/cAm2dlOHs2HQo28lws7YutQUTHH9rviMlyapbTJtJzmYo4I= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=rivosinc.com; spf=pass smtp.mailfrom=rivosinc.com; dkim=pass (2048-bit key) header.d=rivosinc-com.20230601.gappssmtp.com header.i=@rivosinc-com.20230601.gappssmtp.com header.b=l6G8GWjv; arc=none smtp.client-ip=209.85.219.178 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=rivosinc.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=rivosinc.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=rivosinc-com.20230601.gappssmtp.com header.i=@rivosinc-com.20230601.gappssmtp.com header.b="l6G8GWjv" Received: by mail-yb1-f178.google.com with SMTP id 3f1490d57ef6-e0878971aa9so47939276.0 for ; Fri, 19 Jul 2024 15:25:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20230601.gappssmtp.com; s=20230601; t=1721427956; x=1722032756; darn=vger.kernel.org; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=S386uNHUa1mDO7HUkcI0rCKHyM1BbL2df0I71SUcBA0=; b=l6G8GWjvCYF2hnmC/RywfrxuLEVGMKyzL6vXi2IIz9ZsTsIXkBZKgHz7mv1nzLnzMa Qk8P4ToesGKyldyR/n2PPru3LCwR0Fxz5rurn0VyZ2+Xb0immj4TZBX3lUaBWyqPoGq1 a/Zmd0UIIRAN5m4mxCHllyGKXwVgn/5S/H/JrzvyZfDg/HYGPb7cUSmsjeQ6ZhtKsBgV sWl4KV68WCQedowWFtpjemehsTfEjDeVLGqH6tqdbIgJB3/Zox+SICcZ5C9JHxDAAILj Ftth+OtZgUHVYw0ECUWsaT+Cb9luS/fxDDiEMBxUWoG+J6BJROcseRYjWIFc5qz1lt3r +nfQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1721427956; x=1722032756; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=S386uNHUa1mDO7HUkcI0rCKHyM1BbL2df0I71SUcBA0=; b=kuRyESlTqvNJXIXFoUCzMn6gsLzdKeP7Mz0t+1yRLOQaFFWbQzva8Fadps6e+EACcd iz+vaZ9PyyxLEOgVmL/4joECNizTSqTZ4iGLT7XMpqRFsGJI8EE+xPT2kuqwVg3YcFjS mtYtsMeN+k1wQ2z6zDSj24uFB3TbqBNwLqjNoAWw5+E7MCPGz5GHXzO92t8699R38fmC yQrNosXMpAuxoBeAWnDxQ2qb+VDDzc2UqVyWvw76G13FDAWIMqafYJT3HmLg74WX1GHb YaR+TKHzcJGMe6DR2B75NgHG1rICy+aUccs5NctEnMo5V9np+1L9OE4HRiwwaPFz333T j8Wg== X-Forwarded-Encrypted: i=1; AJvYcCXYT0uCikPGjmOCo3Coh+IESwmOc8128TkuLCDccsipfJpgjrHuvq8zjJq/ry2IW6E8FaPOTTqmKkeZHkL14vBgiRfZ1TIVzc9q X-Gm-Message-State: AOJu0YwaMBrPeGXU7sNcI+1Ztqc6/CR0MU7SWR0HVOQYaExIZ1cSoAmZ VsP/x+1vOrtwUgRzK7+D7Q4pr3UEytpV01Be9yGf7xP0DWBfXQp8lvD6gsfdb6Q= X-Google-Smtp-Source: AGHT+IFJ/Xb7HTvxClUkzKPmIMXRkcAoU0Ag2NvfoFtCiJ60OAXbvUitaY7qqrsTDC3Xsq46oxUHdw== X-Received: by 2002:a25:6b45:0:b0:e05:f632:3ef3 with SMTP id 3f1490d57ef6-e05ff2e2ac7mr5211912276.23.1721427955741; Fri, 19 Jul 2024 15:25:55 -0700 (PDT) Received: from ghost ([50.146.0.2]) by smtp.gmail.com with ESMTPSA id 3f1490d57ef6-e086096b428sm699235276.2.2024.07.19.15.25.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Jul 2024 15:25:54 -0700 (PDT) Date: Fri, 19 Jul 2024 15:25:53 -0700 From: Charlie Jenkins To: Evan Green Cc: Jesse Taube , linux-riscv@lists.infradead.org, Jonathan Corbet , Paul Walmsley , Palmer Dabbelt , Albert Ou , Conor Dooley , Rob Herring , Krzysztof Kozlowski , =?iso-8859-1?Q?Cl=E9ment_L=E9ger?= , Andrew Jones , Xiao Wang , Andy Chiu , Eric Biggers , Greentime Hu , =?iso-8859-1?Q?Bj=F6rn_T=F6pel?= , Heiko Stuebner , Costa Shulyupin , Andrew Morton , Baoquan He , Anup Patel , Zong Li , Sami Tolvanen , Ben Dooks , Alexandre Ghiti , "Gustavo A. R. Silva" , Erick Archer , Joel Granados , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org Subject: Re: [PATCH v5 6/7] RISC-V: Report vector unaligned access speed hwprobe Message-ID: References: <20240717180727.4180475-1-jesse@rivosinc.com> <20240717180727.4180475-7-jesse@rivosinc.com> Precedence: bulk X-Mailing-List: linux-doc@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: On Fri, Jul 19, 2024 at 01:00:16PM -0700, Evan Green wrote: > On Wed, Jul 17, 2024 at 11:08 AM Jesse Taube wrote: > > > > Detect if vector misaligned accesses are faster or slower than > > equivalent vector byte accesses. This is useful for usermode to know > > whether vector byte accesses or vector misaligned accesses have a better > > bandwidth for operations like memcpy. > > > > Signed-off-by: Jesse Taube > > Reviewed-by: Charlie Jenkins > > --- > > V1 -> V2: > > - Add Kconfig options > > - Add WORD_EEW to vec-copy-unaligned.S > > V2 -> V3: > > - Remove unnecessary comment > > - Remove local_irq_enable > > V3 -> V4: > > - Add preempt_disable/enable > > - Alphabetize includes in vec-copy-unaligned.S and unaligned_access_speed.c > > - Add duplicate comments above mb() to please checkpatch > > - change all_cpus_vec_supported to all_cpus_vec_unsupported > > so speed is tested if any cpus support unaligned vector accesses > > - Spell out _VECTOR_ in macros > > V4 -> V5: > > - Change void *unused to void *unused __always_unused > > --- > > arch/riscv/Kconfig | 18 +++ > > arch/riscv/kernel/Makefile | 3 +- > > arch/riscv/kernel/copy-unaligned.h | 5 + > > arch/riscv/kernel/sys_hwprobe.c | 6 + > > arch/riscv/kernel/unaligned_access_speed.c | 134 ++++++++++++++++++++- > > arch/riscv/kernel/vec-copy-unaligned.S | 58 +++++++++ > > 6 files changed, 221 insertions(+), 3 deletions(-) > > create mode 100644 arch/riscv/kernel/vec-copy-unaligned.S > > > > diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig > > index ffbe0fdd7fb3..e98139340c1c 100644 > > --- a/arch/riscv/Kconfig > > +++ b/arch/riscv/Kconfig > > @@ -807,6 +807,24 @@ config RISCV_PROBE_VECTOR_UNALIGNED_ACCESS > > will dynamically determine the speed of vector unaligned accesses on > > the underlying system if they are supported. > > > > +config RISCV_SLOW_VECTOR_UNALIGNED_ACCESS > > + bool "Assume the system supports slow vector unaligned memory accesses" > > + depends on NONPORTABLE > > + help > > + Assume that the system supports slow vector unaligned memory accesses. The > > + kernel and userspace programs may not be able to run at all on systems > > + that do not support unaligned memory accesses. > > + > > +config RISCV_EFFICIENT_VECTOR_UNALIGNED_ACCESS > > + bool "Assume the system supports fast vector unaligned memory accesses" > > + depends on NONPORTABLE > > + help > > + Assume that the system supports fast vector unaligned memory accesses. When > > + enabled, this option improves the performance of the kernel on such > > + systems. However, the kernel and userspace programs will run much more > > + slowly, or will not be able to run at all, on systems that do not > > + support efficient unaligned memory accesses. > > + > > endchoice > > > > endmenu # "Platform type" > > diff --git a/arch/riscv/kernel/Makefile b/arch/riscv/kernel/Makefile > > index 5b243d46f4b1..291935a084d5 100644 > > --- a/arch/riscv/kernel/Makefile > > +++ b/arch/riscv/kernel/Makefile > > @@ -64,7 +64,8 @@ obj-$(CONFIG_MMU) += vdso.o vdso/ > > > > obj-$(CONFIG_RISCV_MISALIGNED) += traps_misaligned.o > > obj-$(CONFIG_RISCV_MISALIGNED) += unaligned_access_speed.o > > -obj-$(CONFIG_RISCV_PROBE_UNALIGNED_ACCESS) += copy-unaligned.o > > +obj-$(CONFIG_RISCV_PROBE_UNALIGNED_ACCESS) += copy-unaligned.o > > +obj-$(CONFIG_RISCV_PROBE_VECTOR_UNALIGNED_ACCESS) += vec-copy-unaligned.o > > > > obj-$(CONFIG_FPU) += fpu.o > > obj-$(CONFIG_FPU) += kernel_mode_fpu.o > > diff --git a/arch/riscv/kernel/copy-unaligned.h b/arch/riscv/kernel/copy-unaligned.h > > index e3d70d35b708..85d4d11450cb 100644 > > --- a/arch/riscv/kernel/copy-unaligned.h > > +++ b/arch/riscv/kernel/copy-unaligned.h > > @@ -10,4 +10,9 @@ > > void __riscv_copy_words_unaligned(void *dst, const void *src, size_t size); > > void __riscv_copy_bytes_unaligned(void *dst, const void *src, size_t size); > > > > +#ifdef CONFIG_RISCV_PROBE_VECTOR_UNALIGNED_ACCESS > > +void __riscv_copy_vec_words_unaligned(void *dst, const void *src, size_t size); > > +void __riscv_copy_vec_bytes_unaligned(void *dst, const void *src, size_t size); > > +#endif > > + > > #endif /* __RISCV_KERNEL_COPY_UNALIGNED_H */ > > diff --git a/arch/riscv/kernel/sys_hwprobe.c b/arch/riscv/kernel/sys_hwprobe.c > > index 2e3e324bad38..99d3e63d0444 100644 > > --- a/arch/riscv/kernel/sys_hwprobe.c > > +++ b/arch/riscv/kernel/sys_hwprobe.c > > @@ -221,6 +221,12 @@ static u64 hwprobe_vec_misaligned(const struct cpumask *cpus) > > #else > > static u64 hwprobe_vec_misaligned(const struct cpumask *cpus) > > { > > + if (IS_ENABLED(CONFIG_RISCV_EFFICIENT_VECTOR_UNALIGNED_ACCESS)) > > + return RISCV_HWPROBE_VECTOR_MISALIGNED_FAST; > > + > > + if (IS_ENABLED(CONFIG_RISCV_SLOW_VECTOR_UNALIGNED_ACCESS)) > > + return RISCV_HWPROBE_VECTOR_MISALIGNED_SLOW; > > + > > return RISCV_HWPROBE_VECTOR_MISALIGNED_UNKNOWN; > > } > > #endif > > diff --git a/arch/riscv/kernel/unaligned_access_speed.c b/arch/riscv/kernel/unaligned_access_speed.c > > index 24b8883a23f0..532e9151685b 100644 > > --- a/arch/riscv/kernel/unaligned_access_speed.c > > +++ b/arch/riscv/kernel/unaligned_access_speed.c > > @@ -6,11 +6,13 @@ > > #include > > #include > > #include > > +#include > > #include > > #include > > #include > > #include > > #include > > +#include > > > > #include "copy-unaligned.h" > > > > @@ -267,12 +269,140 @@ static int check_unaligned_access_speed_all_cpus(void) > > } > > #endif > > > > +#ifdef CONFIG_RISCV_PROBE_VECTOR_UNALIGNED_ACCESS > > +static void check_vector_unaligned_access(struct work_struct *work __always_unused) > > +{ > > + int cpu = smp_processor_id(); > > + u64 start_cycles, end_cycles; > > + u64 word_cycles; > > + u64 byte_cycles; > > + int ratio; > > + unsigned long start_jiffies, now; > > + struct page *page; > > + void *dst; > > + void *src; > > + long speed = RISCV_HWPROBE_VECTOR_MISALIGNED_SLOW; > > + > > + if (per_cpu(vector_misaligned_access, cpu) != RISCV_HWPROBE_VECTOR_MISALIGNED_SLOW) > > + return; > > + > > + page = alloc_pages(GFP_KERNEL, MISALIGNED_BUFFER_ORDER); > > + if (!page) { > > + pr_warn("Allocation failure, not measuring vector misaligned performance\n"); > > + return; > > + } > > + > > + /* Make an unaligned destination buffer. */ > > + dst = (void *)((unsigned long)page_address(page) | 0x1); > > + /* Unalign src as well, but differently (off by 1 + 2 = 3). */ > > + src = dst + (MISALIGNED_BUFFER_SIZE / 2); > > + src += 2; > > + word_cycles = -1ULL; > > + > > + /* Do a warmup. */ > > + kernel_vector_begin(); > > + __riscv_copy_vec_words_unaligned(dst, src, MISALIGNED_COPY_SIZE); > > + > > + start_jiffies = jiffies; > > + while ((now = jiffies) == start_jiffies) > > + cpu_relax(); > > + > > + /* > > + * For a fixed amount of time, repeatedly try the function, and take > > + * the best time in cycles as the measurement. > > + */ > > + while (time_before(jiffies, now + (1 << MISALIGNED_ACCESS_JIFFIES_LG2))) { > > + start_cycles = get_cycles64(); > > + /* Ensure the CSR read can't reorder WRT to the copy. */ > > + mb(); > > + __riscv_copy_vec_words_unaligned(dst, src, MISALIGNED_COPY_SIZE); > > + /* Ensure the copy ends before the end time is snapped. */ > > + mb(); > > + end_cycles = get_cycles64(); > > + if ((end_cycles - start_cycles) < word_cycles) > > + word_cycles = end_cycles - start_cycles; > > + } > > + > > + byte_cycles = -1ULL; > > + __riscv_copy_vec_bytes_unaligned(dst, src, MISALIGNED_COPY_SIZE); > > + start_jiffies = jiffies; > > + while ((now = jiffies) == start_jiffies) > > + cpu_relax(); > > + > > + while (time_before(jiffies, now + (1 << MISALIGNED_ACCESS_JIFFIES_LG2))) { > > + start_cycles = get_cycles64(); > > + /* Ensure the CSR read can't reorder WRT to the copy. */ > > + mb(); > > + __riscv_copy_vec_bytes_unaligned(dst, src, MISALIGNED_COPY_SIZE); > > + /* Ensure the copy ends before the end time is snapped. */ > > + mb(); > > + end_cycles = get_cycles64(); > > + if ((end_cycles - start_cycles) < byte_cycles) > > + byte_cycles = end_cycles - start_cycles; > > + } > > + > > + kernel_vector_end(); > > + > > + /* Don't divide by zero. */ > > + if (!word_cycles || !byte_cycles) { > > + pr_warn("cpu%d: rdtime lacks granularity needed to measure unaligned vector access speed\n", > > + cpu); > > + > > + return; > > + } > > + > > + if (word_cycles < byte_cycles) > > + speed = RISCV_HWPROBE_VECTOR_MISALIGNED_FAST; > > + > > + ratio = div_u64((byte_cycles * 100), word_cycles); > > + pr_info("cpu%d: Ratio of vector byte access time to vector unaligned word access is %d.%02d, unaligned accesses are %s\n", > > + cpu, > > + ratio / 100, > > + ratio % 100, > > + (speed == RISCV_HWPROBE_VECTOR_MISALIGNED_FAST) ? "fast" : "slow"); > > + > > + per_cpu(vector_misaligned_access, cpu) = speed; > > +} > > + > > +static int riscv_online_cpu_vec(unsigned int cpu) > > +{ > > + check_vector_unaligned_access(NULL); > > Maybe I missed the call site in another patch, but are you calling > check_vector_unaligned_access_emulated() anywhere in the hotplug path? > Without this, for a CPU that wasn't present at boot, it seems like the > per-cpu variable would be set to its initialized value of UNSUPPORTED, > and then you'd bail early out of check_vector_unaligned_access() at > the "!= SLOW" conditional. > > IMO it would be better if the values truly meant what they said. So we > initialize it to UNKNOWN, unconditionally change to UNSUPPORTED if we > discover it's emulated or there is no vector support, and only set to > SLOW or FAST as a result of probe measurement or Kconfig override. > It's the "SLOW means slow or don't know" from the previous patch > that's bugging me. This creates downstream effects like this "!= SLOW" > conditional (by which you really mean "!= UNKNOWN") that are > challenging to reason about and maintain. > > I have this vague sense that you did this in response to feedback in > an earlier series, but I can't find it now. Yes there has been a lot of back and forth on this. Here is the original discussion: https://lore.kernel.org/lkml/ZmN8gER4RnyoyQT4@ghost/. I originally agreed with Conor that SLOW would be reasonable because it prevented programs from receiving an UNKNOWN which they may be unsure how to handle. The idea here is that programs that rely on misaligned access speed should avoid using misaligned accesses if the speed is UNKNOWN. Reporting SLOW instead of UNKNOWN takes the decision out of the hands of the program, so they don't have to worry about UNKNOWN. However over the course of this series I too have been increasingly unconvinced by this reasoning. It doesn't seem like the kernel's place to make this decision for userspace and should just provide the correct information. The more concrete issue is with CPU hotplug. When a CPU is hotplugged into a new CPU index, it will default to UNSUPPORTED. When the CPU enters check_vector_unaligned_access(), its speed will not be SLOW so the code assumes it has already been probed -- even though it hasn't. The default should be UNKNOWN (instead of UNSUPPORTED) and this code should check for UNKNOWN to determine if the cpu has already been probed. We can test this by booting Linux with the argument "maxcpus=1" and after it boots run: # echo 1 > /sys/devices/system/cpu/cpu1/online [ 40.481153] cpu1: Ratio of byte access time to unaligned word access is 9.05, unaligned accesses are fast # Only the scalar misaligned access speed checker ran. I also verified that check_vector_unaligned_access() sees that the speed is UNKNOWN which is not SLOW so exits. - Charlie > > > -Evan > > > > + return 0; > > +} > > + > > +/* Measure unaligned access speed on all CPUs present at boot in parallel. */ > > +static int vec_check_unaligned_access_speed_all_cpus(void *unused __always_unused) > > +{ > > + schedule_on_each_cpu(check_vector_unaligned_access); > > + > > + /* > > + * Setup hotplug callbacks for any new CPUs that come online or go > > + * offline. > > + */ > > + cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN, "riscv:online", > > + riscv_online_cpu_vec, NULL); > > + > > + return 0; > > +} > > +#else /* CONFIG_RISCV_PROBE_VECTOR_UNALIGNED_ACCESS */ > > +static int vec_check_unaligned_access_speed_all_cpus(void *unused __always_unused) > > +{ > > + return 0; > > +} > > +#endif > > + > > static int check_unaligned_access_all_cpus(void) > > { > > - bool all_cpus_emulated; > > + bool all_cpus_emulated, all_cpus_vec_unsupported; > > > > all_cpus_emulated = check_unaligned_access_emulated_all_cpus(); > > - check_vector_unaligned_access_emulated_all_cpus(); > > + all_cpus_vec_unsupported = check_vector_unaligned_access_emulated_all_cpus(); > > + > > + if (!all_cpus_vec_unsupported && > > + IS_ENABLED(CONFIG_RISCV_PROBE_VECTOR_UNALIGNED_ACCESS)) { > > + kthread_run(vec_check_unaligned_access_speed_all_cpus, > > + NULL, "vec_check_unaligned_access_speed_all_cpus"); > > + } > > > > if (!all_cpus_emulated) > > return check_unaligned_access_speed_all_cpus(); > > diff --git a/arch/riscv/kernel/vec-copy-unaligned.S b/arch/riscv/kernel/vec-copy-unaligned.S > > new file mode 100644 > > index 000000000000..d16f19f1b3b6 > > --- /dev/null > > +++ b/arch/riscv/kernel/vec-copy-unaligned.S > > @@ -0,0 +1,58 @@ > > +/* SPDX-License-Identifier: GPL-2.0 */ > > +/* Copyright (C) 2024 Rivos Inc. */ > > + > > +#include > > +#include > > +#include > > + > > + .text > > + > > +#define WORD_EEW 32 > > + > > +#define WORD_SEW CONCATENATE(e, WORD_EEW) > > +#define VEC_L CONCATENATE(vle, WORD_EEW).v > > +#define VEC_S CONCATENATE(vle, WORD_EEW).v > > + > > +/* void __riscv_copy_vec_words_unaligned(void *, const void *, size_t) */ > > +/* Performs a memcpy without aligning buffers, using word loads and stores. */ > > +/* Note: The size is truncated to a multiple of WORD_EEW */ > > +SYM_FUNC_START(__riscv_copy_vec_words_unaligned) > > + andi a4, a2, ~(WORD_EEW-1) > > + beqz a4, 2f > > + add a3, a1, a4 > > + .option push > > + .option arch, +zve32x > > +1: > > + vsetivli t0, 8, WORD_SEW, m8, ta, ma > > + VEC_L v0, (a1) > > + VEC_S v0, (a0) > > + addi a0, a0, WORD_EEW > > + addi a1, a1, WORD_EEW > > + bltu a1, a3, 1b > > + > > +2: > > + .option pop > > + ret > > +SYM_FUNC_END(__riscv_copy_vec_words_unaligned) > > + > > +/* void __riscv_copy_vec_bytes_unaligned(void *, const void *, size_t) */ > > +/* Performs a memcpy without aligning buffers, using only byte accesses. */ > > +/* Note: The size is truncated to a multiple of 8 */ > > +SYM_FUNC_START(__riscv_copy_vec_bytes_unaligned) > > + andi a4, a2, ~(8-1) > > + beqz a4, 2f > > + add a3, a1, a4 > > + .option push > > + .option arch, +zve32x > > +1: > > + vsetivli t0, 8, e8, m8, ta, ma > > + vle8.v v0, (a1) > > + vse8.v v0, (a0) > > + addi a0, a0, 8 > > + addi a1, a1, 8 > > + bltu a1, a3, 1b > > + > > +2: > > + .option pop > > + ret > > +SYM_FUNC_END(__riscv_copy_vec_bytes_unaligned) > > -- > > 2.45.2 > > From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 0E5D1C3DA5D for ; Fri, 19 Jul 2024 22:26:09 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=h0lO4/5vsqmAXpx8e5JrfPvV3HotfBPJ3gcORCHLm2k=; b=elIWgFHZRuxdQZ pG0wHSyZzMrzux/RH9XVMddnGzoqHVWgczVs5wzHxtAvk862Em97t3dGq99TxB3GeOmQqr45cQT7K ErTV5RYjlMhmn02CwjytgpBZnqkFQQcb2nGPDne2ySBGK4eY07Etqx/Go8IT2nKIVflSM/+lqs2ea nPJAmfh6ocXtNR8NY0ucS0vU4U5vByrhH3QNdW25PaKYr5NYRaJUiVRT+/n5dWshWDbFlIhgtPSTK mvbL9DLAD5SNlHlwPeIW3sWl1G2KJUnGoOE9QUsLQd5A69mPANjft5h4D/qfckQ8Y/O7Mrpq9e7tB ukTB5TVR+kK+5KDaO8uw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1sUw37-00000003uD3-1xiR; Fri, 19 Jul 2024 22:26:01 +0000 Received: from mail-yb1-xb36.google.com ([2607:f8b0:4864:20::b36]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1sUw33-00000003uCP-0alp for linux-riscv@lists.infradead.org; Fri, 19 Jul 2024 22:25:59 +0000 Received: by mail-yb1-xb36.google.com with SMTP id 3f1490d57ef6-e0878971aa9so47936276.0 for ; Fri, 19 Jul 2024 15:25:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20230601.gappssmtp.com; s=20230601; t=1721427956; x=1722032756; darn=lists.infradead.org; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=S386uNHUa1mDO7HUkcI0rCKHyM1BbL2df0I71SUcBA0=; b=n/F6978BweSTWQrAWpa/0wyo3dMjX7wSsR1eyDnPIMMjqvhNrPIg8BtpfLMFxdOBek bfR+32uY2jAqjIT723xEy/ls6/G0eN1SEEN5ZkOp+oVjC0e5Nzh6E3Srzze2UyYFvVdD ynj8TsESjeXf7pY6tRPgsLnc4L9S+MiUJ5154C8WmgsETJsOOhTWqmaA6ZM9v9Yn7H8l JFVQTM7OqELjp8F252esZIDuGVOYkh9QtV0T00XD8peQY2A3ev9GNDTIsW93va8E844b biDEpU7nHebXrVvnjEFf0683L9F8orlRIWEhIO7Mv0C41BepKdo/MbBLjaPHXQmVT+TA 3Czg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1721427956; x=1722032756; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=S386uNHUa1mDO7HUkcI0rCKHyM1BbL2df0I71SUcBA0=; b=tPTd24o+k4/FbFtwMn1d6msjjbj5x3rX+ZyiAnooYEA5yLUuo2UTIbjIxaj80T7epk QZPUfA4ZzVMgoa3CC5B+wT4tWOKYGqPHF5y1VnanqRpb72MBNHGkQcFAngAlcpSf3mvA qp8+XgNs1IDF6tindKpNd3qPJwZZARksbI+mA95s9YT92D8nD+8pk3Q3XJt8MMb0VALZ 21K+heZj2uhVVWVQ1ycaufg4UKuknh0vRCjPCX2MFzLy33OKPuvdlCOK+Dy0qlQ7nxQT 2tXKjOjwU7oYjjL/CNnrit3eH0uwnybxvloCugXXq11ps0R1OTZoU9NOGm8Ll/AVV5NJ K6ng== X-Forwarded-Encrypted: i=1; AJvYcCXwrHCrOsAyv17Elrd6ef+eaabXBVpU08E9Qs8KTV1kU4U0j0o1Kfmmjyal8xmWlqE/sMJDWiKAnNcCOHtjJ02lZuwE+kyZs9q20meSB4pl X-Gm-Message-State: AOJu0Ywl50t66zWvfkQ8E7GyfSnY/tpCXpMSK64yModfKuA3mboPxek9 uz7ePqjZwKE0yiBY9qHkgzkpV1w55BR5WOMZusI8W2KD9WYefyz/O1T8kXsNM7M= X-Google-Smtp-Source: AGHT+IFJ/Xb7HTvxClUkzKPmIMXRkcAoU0Ag2NvfoFtCiJ60OAXbvUitaY7qqrsTDC3Xsq46oxUHdw== X-Received: by 2002:a25:6b45:0:b0:e05:f632:3ef3 with SMTP id 3f1490d57ef6-e05ff2e2ac7mr5211912276.23.1721427955741; Fri, 19 Jul 2024 15:25:55 -0700 (PDT) Received: from ghost ([50.146.0.2]) by smtp.gmail.com with ESMTPSA id 3f1490d57ef6-e086096b428sm699235276.2.2024.07.19.15.25.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Jul 2024 15:25:54 -0700 (PDT) Date: Fri, 19 Jul 2024 15:25:53 -0700 From: Charlie Jenkins To: Evan Green Cc: Jesse Taube , linux-riscv@lists.infradead.org, Jonathan Corbet , Paul Walmsley , Palmer Dabbelt , Albert Ou , Conor Dooley , Rob Herring , Krzysztof Kozlowski , =?iso-8859-1?Q?Cl=E9ment_L=E9ger?= , Andrew Jones , Xiao Wang , Andy Chiu , Eric Biggers , Greentime Hu , =?iso-8859-1?Q?Bj=F6rn_T=F6pel?= , Heiko Stuebner , Costa Shulyupin , Andrew Morton , Baoquan He , Anup Patel , Zong Li , Sami Tolvanen , Ben Dooks , Alexandre Ghiti , "Gustavo A. R. Silva" , Erick Archer , Joel Granados , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org Subject: Re: [PATCH v5 6/7] RISC-V: Report vector unaligned access speed hwprobe Message-ID: References: <20240717180727.4180475-1-jesse@rivosinc.com> <20240717180727.4180475-7-jesse@rivosinc.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240719_152557_481594_56784E64 X-CRM114-Status: GOOD ( 46.46 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org T24gRnJpLCBKdWwgMTksIDIwMjQgYXQgMDE6MDA6MTZQTSAtMDcwMCwgRXZhbiBHcmVlbiB3cm90 ZToKPiBPbiBXZWQsIEp1bCAxNywgMjAyNCBhdCAxMTowOOKAr0FNIEplc3NlIFRhdWJlIDxqZXNz ZUByaXZvc2luYy5jb20+IHdyb3RlOgo+ID4KPiA+IERldGVjdCBpZiB2ZWN0b3IgbWlzYWxpZ25l ZCBhY2Nlc3NlcyBhcmUgZmFzdGVyIG9yIHNsb3dlciB0aGFuCj4gPiBlcXVpdmFsZW50IHZlY3Rv ciBieXRlIGFjY2Vzc2VzLiBUaGlzIGlzIHVzZWZ1bCBmb3IgdXNlcm1vZGUgdG8ga25vdwo+ID4g d2hldGhlciB2ZWN0b3IgYnl0ZSBhY2Nlc3NlcyBvciB2ZWN0b3IgbWlzYWxpZ25lZCBhY2Nlc3Nl cyBoYXZlIGEgYmV0dGVyCj4gPiBiYW5kd2lkdGggZm9yIG9wZXJhdGlvbnMgbGlrZSBtZW1jcHku Cj4gPgo+ID4gU2lnbmVkLW9mZi1ieTogSmVzc2UgVGF1YmUgPGplc3NlQHJpdm9zaW5jLmNvbT4K PiA+IFJldmlld2VkLWJ5OiBDaGFybGllIEplbmtpbnMgPGNoYXJsaWVAcml2b3NpbmMuY29tPgo+ ID4gLS0tCj4gPiBWMSAtPiBWMjoKPiA+ICAtIEFkZCBLY29uZmlnIG9wdGlvbnMKPiA+ICAtIEFk ZCBXT1JEX0VFVyB0byB2ZWMtY29weS11bmFsaWduZWQuUwo+ID4gVjIgLT4gVjM6Cj4gPiAgLSBS ZW1vdmUgdW5uZWNlc3NhcnkgY29tbWVudAo+ID4gIC0gUmVtb3ZlIGxvY2FsX2lycV9lbmFibGUK PiA+IFYzIC0+IFY0Ogo+ID4gIC0gQWRkIHByZWVtcHRfZGlzYWJsZS9lbmFibGUKPiA+ICAtIEFs cGhhYmV0aXplIGluY2x1ZGVzIGluIHZlYy1jb3B5LXVuYWxpZ25lZC5TIGFuZCB1bmFsaWduZWRf YWNjZXNzX3NwZWVkLmMKPiA+ICAtIEFkZCBkdXBsaWNhdGUgY29tbWVudHMgYWJvdmUgbWIoKSB0 byBwbGVhc2UgY2hlY2twYXRjaAo+ID4gIC0gY2hhbmdlIGFsbF9jcHVzX3ZlY19zdXBwb3J0ZWQg dG8gYWxsX2NwdXNfdmVjX3Vuc3VwcG9ydGVkCj4gPiAgICAgc28gc3BlZWQgaXMgdGVzdGVkIGlm IGFueSBjcHVzIHN1cHBvcnQgdW5hbGlnbmVkIHZlY3RvciBhY2Nlc3Nlcwo+ID4gIC0gU3BlbGwg b3V0IF9WRUNUT1JfIGluIG1hY3Jvcwo+ID4gVjQgLT4gVjU6Cj4gPiAgLSBDaGFuZ2Ugdm9pZCAq dW51c2VkIHRvIHZvaWQgKnVudXNlZCBfX2Fsd2F5c191bnVzZWQKPiA+IC0tLQo+ID4gIGFyY2gv cmlzY3YvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAxOCArKysKPiA+ICBhcmNo L3Jpc2N2L2tlcm5lbC9NYWtlZmlsZSAgICAgICAgICAgICAgICAgfCAgIDMgKy0KPiA+ICBhcmNo L3Jpc2N2L2tlcm5lbC9jb3B5LXVuYWxpZ25lZC5oICAgICAgICAgfCAgIDUgKwo+ID4gIGFyY2gv cmlzY3Yva2VybmVsL3N5c19od3Byb2JlLmMgICAgICAgICAgICB8ICAgNiArCj4gPiAgYXJjaC9y aXNjdi9rZXJuZWwvdW5hbGlnbmVkX2FjY2Vzc19zcGVlZC5jIHwgMTM0ICsrKysrKysrKysrKysr KysrKysrLQo+ID4gIGFyY2gvcmlzY3Yva2VybmVsL3ZlYy1jb3B5LXVuYWxpZ25lZC5TICAgICB8 ICA1OCArKysrKysrKysKPiA+ICA2IGZpbGVzIGNoYW5nZWQsIDIyMSBpbnNlcnRpb25zKCspLCAz IGRlbGV0aW9ucygtKQo+ID4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jpc2N2L2tlcm5lbC92 ZWMtY29weS11bmFsaWduZWQuUwo+ID4KPiA+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L0tjb25m aWcgYi9hcmNoL3Jpc2N2L0tjb25maWcKPiA+IGluZGV4IGZmYmUwZmRkN2ZiMy4uZTk4MTM5MzQw YzFjIDEwMDY0NAo+ID4gLS0tIGEvYXJjaC9yaXNjdi9LY29uZmlnCj4gPiArKysgYi9hcmNoL3Jp c2N2L0tjb25maWcKPiA+IEBAIC04MDcsNiArODA3LDI0IEBAIGNvbmZpZyBSSVNDVl9QUk9CRV9W RUNUT1JfVU5BTElHTkVEX0FDQ0VTUwo+ID4gICAgICAgICAgIHdpbGwgZHluYW1pY2FsbHkgZGV0 ZXJtaW5lIHRoZSBzcGVlZCBvZiB2ZWN0b3IgdW5hbGlnbmVkIGFjY2Vzc2VzIG9uCj4gPiAgICAg ICAgICAgdGhlIHVuZGVybHlpbmcgc3lzdGVtIGlmIHRoZXkgYXJlIHN1cHBvcnRlZC4KPiA+Cj4g PiArY29uZmlnIFJJU0NWX1NMT1dfVkVDVE9SX1VOQUxJR05FRF9BQ0NFU1MKPiA+ICsgICAgICAg Ym9vbCAiQXNzdW1lIHRoZSBzeXN0ZW0gc3VwcG9ydHMgc2xvdyB2ZWN0b3IgdW5hbGlnbmVkIG1l bW9yeSBhY2Nlc3NlcyIKPiA+ICsgICAgICAgZGVwZW5kcyBvbiBOT05QT1JUQUJMRQo+ID4gKyAg ICAgICBoZWxwCj4gPiArICAgICAgICAgQXNzdW1lIHRoYXQgdGhlIHN5c3RlbSBzdXBwb3J0cyBz bG93IHZlY3RvciB1bmFsaWduZWQgbWVtb3J5IGFjY2Vzc2VzLiBUaGUKPiA+ICsgICAgICAgICBr ZXJuZWwgYW5kIHVzZXJzcGFjZSBwcm9ncmFtcyBtYXkgbm90IGJlIGFibGUgdG8gcnVuIGF0IGFs bCBvbiBzeXN0ZW1zCj4gPiArICAgICAgICAgdGhhdCBkbyBub3Qgc3VwcG9ydCB1bmFsaWduZWQg bWVtb3J5IGFjY2Vzc2VzLgo+ID4gKwo+ID4gK2NvbmZpZyBSSVNDVl9FRkZJQ0lFTlRfVkVDVE9S X1VOQUxJR05FRF9BQ0NFU1MKPiA+ICsgICAgICAgYm9vbCAiQXNzdW1lIHRoZSBzeXN0ZW0gc3Vw cG9ydHMgZmFzdCB2ZWN0b3IgdW5hbGlnbmVkIG1lbW9yeSBhY2Nlc3NlcyIKPiA+ICsgICAgICAg ZGVwZW5kcyBvbiBOT05QT1JUQUJMRQo+ID4gKyAgICAgICBoZWxwCj4gPiArICAgICAgICAgQXNz dW1lIHRoYXQgdGhlIHN5c3RlbSBzdXBwb3J0cyBmYXN0IHZlY3RvciB1bmFsaWduZWQgbWVtb3J5 IGFjY2Vzc2VzLiBXaGVuCj4gPiArICAgICAgICAgZW5hYmxlZCwgdGhpcyBvcHRpb24gaW1wcm92 ZXMgdGhlIHBlcmZvcm1hbmNlIG9mIHRoZSBrZXJuZWwgb24gc3VjaAo+ID4gKyAgICAgICAgIHN5 c3RlbXMuIEhvd2V2ZXIsIHRoZSBrZXJuZWwgYW5kIHVzZXJzcGFjZSBwcm9ncmFtcyB3aWxsIHJ1 biBtdWNoIG1vcmUKPiA+ICsgICAgICAgICBzbG93bHksIG9yIHdpbGwgbm90IGJlIGFibGUgdG8g cnVuIGF0IGFsbCwgb24gc3lzdGVtcyB0aGF0IGRvIG5vdAo+ID4gKyAgICAgICAgIHN1cHBvcnQg ZWZmaWNpZW50IHVuYWxpZ25lZCBtZW1vcnkgYWNjZXNzZXMuCj4gPiArCj4gPiAgZW5kY2hvaWNl Cj4gPgo+ID4gIGVuZG1lbnUgIyAiUGxhdGZvcm0gdHlwZSIKPiA+IGRpZmYgLS1naXQgYS9hcmNo L3Jpc2N2L2tlcm5lbC9NYWtlZmlsZSBiL2FyY2gvcmlzY3Yva2VybmVsL01ha2VmaWxlCj4gPiBp bmRleCA1YjI0M2Q0NmY0YjEuLjI5MTkzNWEwODRkNSAxMDA2NDQKPiA+IC0tLSBhL2FyY2gvcmlz Y3Yva2VybmVsL01ha2VmaWxlCj4gPiArKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9NYWtlZmlsZQo+ ID4gQEAgLTY0LDcgKzY0LDggQEAgb2JqLSQoQ09ORklHX01NVSkgKz0gdmRzby5vIHZkc28vCj4g Pgo+ID4gIG9iai0kKENPTkZJR19SSVNDVl9NSVNBTElHTkVEKSArPSB0cmFwc19taXNhbGlnbmVk Lm8KPiA+ICBvYmotJChDT05GSUdfUklTQ1ZfTUlTQUxJR05FRCkgKz0gdW5hbGlnbmVkX2FjY2Vz c19zcGVlZC5vCj4gPiAtb2JqLSQoQ09ORklHX1JJU0NWX1BST0JFX1VOQUxJR05FRF9BQ0NFU1Mp ICAgICArPSBjb3B5LXVuYWxpZ25lZC5vCj4gPiArb2JqLSQoQ09ORklHX1JJU0NWX1BST0JFX1VO QUxJR05FRF9BQ0NFU1MpICAgICAgICAgICAgICs9IGNvcHktdW5hbGlnbmVkLm8KPiA+ICtvYmot JChDT05GSUdfUklTQ1ZfUFJPQkVfVkVDVE9SX1VOQUxJR05FRF9BQ0NFU1MpICAgICAgKz0gdmVj LWNvcHktdW5hbGlnbmVkLm8KPiA+Cj4gPiAgb2JqLSQoQ09ORklHX0ZQVSkgICAgICAgICAgICAg ICs9IGZwdS5vCj4gPiAgb2JqLSQoQ09ORklHX0ZQVSkgICAgICAgICAgICAgICs9IGtlcm5lbF9t b2RlX2ZwdS5vCj4gPiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwvY29weS11bmFsaWdu ZWQuaCBiL2FyY2gvcmlzY3Yva2VybmVsL2NvcHktdW5hbGlnbmVkLmgKPiA+IGluZGV4IGUzZDcw ZDM1YjcwOC4uODVkNGQxMTQ1MGNiIDEwMDY0NAo+ID4gLS0tIGEvYXJjaC9yaXNjdi9rZXJuZWwv Y29weS11bmFsaWduZWQuaAo+ID4gKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvY29weS11bmFsaWdu ZWQuaAo+ID4gQEAgLTEwLDQgKzEwLDkgQEAKPiA+ICB2b2lkIF9fcmlzY3ZfY29weV93b3Jkc191 bmFsaWduZWQodm9pZCAqZHN0LCBjb25zdCB2b2lkICpzcmMsIHNpemVfdCBzaXplKTsKPiA+ICB2 b2lkIF9fcmlzY3ZfY29weV9ieXRlc191bmFsaWduZWQodm9pZCAqZHN0LCBjb25zdCB2b2lkICpz cmMsIHNpemVfdCBzaXplKTsKPiA+Cj4gPiArI2lmZGVmIENPTkZJR19SSVNDVl9QUk9CRV9WRUNU T1JfVU5BTElHTkVEX0FDQ0VTUwo+ID4gK3ZvaWQgX19yaXNjdl9jb3B5X3ZlY193b3Jkc191bmFs aWduZWQodm9pZCAqZHN0LCBjb25zdCB2b2lkICpzcmMsIHNpemVfdCBzaXplKTsKPiA+ICt2b2lk IF9fcmlzY3ZfY29weV92ZWNfYnl0ZXNfdW5hbGlnbmVkKHZvaWQgKmRzdCwgY29uc3Qgdm9pZCAq c3JjLCBzaXplX3Qgc2l6ZSk7Cj4gPiArI2VuZGlmCj4gPiArCj4gPiAgI2VuZGlmIC8qIF9fUklT Q1ZfS0VSTkVMX0NPUFlfVU5BTElHTkVEX0ggKi8KPiA+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2 L2tlcm5lbC9zeXNfaHdwcm9iZS5jIGIvYXJjaC9yaXNjdi9rZXJuZWwvc3lzX2h3cHJvYmUuYwo+ ID4gaW5kZXggMmUzZTMyNGJhZDM4Li45OWQzZTYzZDA0NDQgMTAwNjQ0Cj4gPiAtLS0gYS9hcmNo L3Jpc2N2L2tlcm5lbC9zeXNfaHdwcm9iZS5jCj4gPiArKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9z eXNfaHdwcm9iZS5jCj4gPiBAQCAtMjIxLDYgKzIyMSwxMiBAQCBzdGF0aWMgdTY0IGh3cHJvYmVf dmVjX21pc2FsaWduZWQoY29uc3Qgc3RydWN0IGNwdW1hc2sgKmNwdXMpCj4gPiAgI2Vsc2UKPiA+ ICBzdGF0aWMgdTY0IGh3cHJvYmVfdmVjX21pc2FsaWduZWQoY29uc3Qgc3RydWN0IGNwdW1hc2sg KmNwdXMpCj4gPiAgewo+ID4gKyAgICAgICBpZiAoSVNfRU5BQkxFRChDT05GSUdfUklTQ1ZfRUZG SUNJRU5UX1ZFQ1RPUl9VTkFMSUdORURfQUNDRVNTKSkKPiA+ICsgICAgICAgICAgICAgICByZXR1 cm4gUklTQ1ZfSFdQUk9CRV9WRUNUT1JfTUlTQUxJR05FRF9GQVNUOwo+ID4gKwo+ID4gKyAgICAg ICBpZiAoSVNfRU5BQkxFRChDT05GSUdfUklTQ1ZfU0xPV19WRUNUT1JfVU5BTElHTkVEX0FDQ0VT UykpCj4gPiArICAgICAgICAgICAgICAgcmV0dXJuIFJJU0NWX0hXUFJPQkVfVkVDVE9SX01JU0FM SUdORURfU0xPVzsKPiA+ICsKPiA+ICAgICAgICAgcmV0dXJuIFJJU0NWX0hXUFJPQkVfVkVDVE9S X01JU0FMSUdORURfVU5LTk9XTjsKPiA+ICB9Cj4gPiAgI2VuZGlmCj4gPiBkaWZmIC0tZ2l0IGEv YXJjaC9yaXNjdi9rZXJuZWwvdW5hbGlnbmVkX2FjY2Vzc19zcGVlZC5jIGIvYXJjaC9yaXNjdi9r ZXJuZWwvdW5hbGlnbmVkX2FjY2Vzc19zcGVlZC5jCj4gPiBpbmRleCAyNGI4ODgzYTIzZjAuLjUz MmU5MTUxNjg1YiAxMDA2NDQKPiA+IC0tLSBhL2FyY2gvcmlzY3Yva2VybmVsL3VuYWxpZ25lZF9h Y2Nlc3Nfc3BlZWQuYwo+ID4gKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvdW5hbGlnbmVkX2FjY2Vz c19zcGVlZC5jCj4gPiBAQCAtNiwxMSArNiwxMyBAQAo+ID4gICNpbmNsdWRlIDxsaW51eC9jcHUu aD4KPiA+ICAjaW5jbHVkZSA8bGludXgvY3B1bWFzay5oPgo+ID4gICNpbmNsdWRlIDxsaW51eC9q dW1wX2xhYmVsLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L2t0aHJlYWQuaD4KPiA+ICAjaW5jbHVk ZSA8bGludXgvbW0uaD4KPiA+ICAjaW5jbHVkZSA8bGludXgvc21wLmg+Cj4gPiAgI2luY2x1ZGUg PGxpbnV4L3R5cGVzLmg+Cj4gPiAgI2luY2x1ZGUgPGFzbS9jcHVmZWF0dXJlLmg+Cj4gPiAgI2lu Y2x1ZGUgPGFzbS9od3Byb2JlLmg+Cj4gPiArI2luY2x1ZGUgPGFzbS92ZWN0b3IuaD4KPiA+Cj4g PiAgI2luY2x1ZGUgImNvcHktdW5hbGlnbmVkLmgiCj4gPgo+ID4gQEAgLTI2NywxMiArMjY5LDE0 MCBAQCBzdGF0aWMgaW50IGNoZWNrX3VuYWxpZ25lZF9hY2Nlc3Nfc3BlZWRfYWxsX2NwdXModm9p ZCkKPiA+ICB9Cj4gPiAgI2VuZGlmCj4gPgo+ID4gKyNpZmRlZiBDT05GSUdfUklTQ1ZfUFJPQkVf VkVDVE9SX1VOQUxJR05FRF9BQ0NFU1MKPiA+ICtzdGF0aWMgdm9pZCBjaGVja192ZWN0b3JfdW5h bGlnbmVkX2FjY2VzcyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmsgX19hbHdheXNfdW51c2VkKQo+ ID4gK3sKPiA+ICsgICAgICAgaW50IGNwdSA9IHNtcF9wcm9jZXNzb3JfaWQoKTsKPiA+ICsgICAg ICAgdTY0IHN0YXJ0X2N5Y2xlcywgZW5kX2N5Y2xlczsKPiA+ICsgICAgICAgdTY0IHdvcmRfY3lj bGVzOwo+ID4gKyAgICAgICB1NjQgYnl0ZV9jeWNsZXM7Cj4gPiArICAgICAgIGludCByYXRpbzsK PiA+ICsgICAgICAgdW5zaWduZWQgbG9uZyBzdGFydF9qaWZmaWVzLCBub3c7Cj4gPiArICAgICAg IHN0cnVjdCBwYWdlICpwYWdlOwo+ID4gKyAgICAgICB2b2lkICpkc3Q7Cj4gPiArICAgICAgIHZv aWQgKnNyYzsKPiA+ICsgICAgICAgbG9uZyBzcGVlZCA9IFJJU0NWX0hXUFJPQkVfVkVDVE9SX01J U0FMSUdORURfU0xPVzsKPiA+ICsKPiA+ICsgICAgICAgaWYgKHBlcl9jcHUodmVjdG9yX21pc2Fs aWduZWRfYWNjZXNzLCBjcHUpICE9IFJJU0NWX0hXUFJPQkVfVkVDVE9SX01JU0FMSUdORURfU0xP VykKPiA+ICsgICAgICAgICAgICAgICByZXR1cm47Cj4gPiArCj4gPiArICAgICAgIHBhZ2UgPSBh bGxvY19wYWdlcyhHRlBfS0VSTkVMLCBNSVNBTElHTkVEX0JVRkZFUl9PUkRFUik7Cj4gPiArICAg ICAgIGlmICghcGFnZSkgewo+ID4gKyAgICAgICAgICAgICAgIHByX3dhcm4oIkFsbG9jYXRpb24g ZmFpbHVyZSwgbm90IG1lYXN1cmluZyB2ZWN0b3IgbWlzYWxpZ25lZCBwZXJmb3JtYW5jZVxuIik7 Cj4gPiArICAgICAgICAgICAgICAgcmV0dXJuOwo+ID4gKyAgICAgICB9Cj4gPiArCj4gPiArICAg ICAgIC8qIE1ha2UgYW4gdW5hbGlnbmVkIGRlc3RpbmF0aW9uIGJ1ZmZlci4gKi8KPiA+ICsgICAg ICAgZHN0ID0gKHZvaWQgKikoKHVuc2lnbmVkIGxvbmcpcGFnZV9hZGRyZXNzKHBhZ2UpIHwgMHgx KTsKPiA+ICsgICAgICAgLyogVW5hbGlnbiBzcmMgYXMgd2VsbCwgYnV0IGRpZmZlcmVudGx5IChv ZmYgYnkgMSArIDIgPSAzKS4gKi8KPiA+ICsgICAgICAgc3JjID0gZHN0ICsgKE1JU0FMSUdORURf QlVGRkVSX1NJWkUgLyAyKTsKPiA+ICsgICAgICAgc3JjICs9IDI7Cj4gPiArICAgICAgIHdvcmRf Y3ljbGVzID0gLTFVTEw7Cj4gPiArCj4gPiArICAgICAgIC8qIERvIGEgd2FybXVwLiAqLwo+ID4g KyAgICAgICBrZXJuZWxfdmVjdG9yX2JlZ2luKCk7Cj4gPiArICAgICAgIF9fcmlzY3ZfY29weV92 ZWNfd29yZHNfdW5hbGlnbmVkKGRzdCwgc3JjLCBNSVNBTElHTkVEX0NPUFlfU0laRSk7Cj4gPiAr Cj4gPiArICAgICAgIHN0YXJ0X2ppZmZpZXMgPSBqaWZmaWVzOwo+ID4gKyAgICAgICB3aGlsZSAo KG5vdyA9IGppZmZpZXMpID09IHN0YXJ0X2ppZmZpZXMpCj4gPiArICAgICAgICAgICAgICAgY3B1 X3JlbGF4KCk7Cj4gPiArCj4gPiArICAgICAgIC8qCj4gPiArICAgICAgICAqIEZvciBhIGZpeGVk IGFtb3VudCBvZiB0aW1lLCByZXBlYXRlZGx5IHRyeSB0aGUgZnVuY3Rpb24sIGFuZCB0YWtlCj4g PiArICAgICAgICAqIHRoZSBiZXN0IHRpbWUgaW4gY3ljbGVzIGFzIHRoZSBtZWFzdXJlbWVudC4K PiA+ICsgICAgICAgICovCj4gPiArICAgICAgIHdoaWxlICh0aW1lX2JlZm9yZShqaWZmaWVzLCBu b3cgKyAoMSA8PCBNSVNBTElHTkVEX0FDQ0VTU19KSUZGSUVTX0xHMikpKSB7Cj4gPiArICAgICAg ICAgICAgICAgc3RhcnRfY3ljbGVzID0gZ2V0X2N5Y2xlczY0KCk7Cj4gPiArICAgICAgICAgICAg ICAgLyogRW5zdXJlIHRoZSBDU1IgcmVhZCBjYW4ndCByZW9yZGVyIFdSVCB0byB0aGUgY29weS4g Ki8KPiA+ICsgICAgICAgICAgICAgICBtYigpOwo+ID4gKyAgICAgICAgICAgICAgIF9fcmlzY3Zf Y29weV92ZWNfd29yZHNfdW5hbGlnbmVkKGRzdCwgc3JjLCBNSVNBTElHTkVEX0NPUFlfU0laRSk7 Cj4gPiArICAgICAgICAgICAgICAgLyogRW5zdXJlIHRoZSBjb3B5IGVuZHMgYmVmb3JlIHRoZSBl bmQgdGltZSBpcyBzbmFwcGVkLiAqLwo+ID4gKyAgICAgICAgICAgICAgIG1iKCk7Cj4gPiArICAg ICAgICAgICAgICAgZW5kX2N5Y2xlcyA9IGdldF9jeWNsZXM2NCgpOwo+ID4gKyAgICAgICAgICAg ICAgIGlmICgoZW5kX2N5Y2xlcyAtIHN0YXJ0X2N5Y2xlcykgPCB3b3JkX2N5Y2xlcykKPiA+ICsg ICAgICAgICAgICAgICAgICAgICAgIHdvcmRfY3ljbGVzID0gZW5kX2N5Y2xlcyAtIHN0YXJ0X2N5 Y2xlczsKPiA+ICsgICAgICAgfQo+ID4gKwo+ID4gKyAgICAgICBieXRlX2N5Y2xlcyA9IC0xVUxM Owo+ID4gKyAgICAgICBfX3Jpc2N2X2NvcHlfdmVjX2J5dGVzX3VuYWxpZ25lZChkc3QsIHNyYywg TUlTQUxJR05FRF9DT1BZX1NJWkUpOwo+ID4gKyAgICAgICBzdGFydF9qaWZmaWVzID0gamlmZmll czsKPiA+ICsgICAgICAgd2hpbGUgKChub3cgPSBqaWZmaWVzKSA9PSBzdGFydF9qaWZmaWVzKQo+ ID4gKyAgICAgICAgICAgICAgIGNwdV9yZWxheCgpOwo+ID4gKwo+ID4gKyAgICAgICB3aGlsZSAo dGltZV9iZWZvcmUoamlmZmllcywgbm93ICsgKDEgPDwgTUlTQUxJR05FRF9BQ0NFU1NfSklGRklF U19MRzIpKSkgewo+ID4gKyAgICAgICAgICAgICAgIHN0YXJ0X2N5Y2xlcyA9IGdldF9jeWNsZXM2 NCgpOwo+ID4gKyAgICAgICAgICAgICAgIC8qIEVuc3VyZSB0aGUgQ1NSIHJlYWQgY2FuJ3QgcmVv cmRlciBXUlQgdG8gdGhlIGNvcHkuICovCj4gPiArICAgICAgICAgICAgICAgbWIoKTsKPiA+ICsg ICAgICAgICAgICAgICBfX3Jpc2N2X2NvcHlfdmVjX2J5dGVzX3VuYWxpZ25lZChkc3QsIHNyYywg TUlTQUxJR05FRF9DT1BZX1NJWkUpOwo+ID4gKyAgICAgICAgICAgICAgIC8qIEVuc3VyZSB0aGUg Y29weSBlbmRzIGJlZm9yZSB0aGUgZW5kIHRpbWUgaXMgc25hcHBlZC4gKi8KPiA+ICsgICAgICAg ICAgICAgICBtYigpOwo+ID4gKyAgICAgICAgICAgICAgIGVuZF9jeWNsZXMgPSBnZXRfY3ljbGVz NjQoKTsKPiA+ICsgICAgICAgICAgICAgICBpZiAoKGVuZF9jeWNsZXMgLSBzdGFydF9jeWNsZXMp IDwgYnl0ZV9jeWNsZXMpCj4gPiArICAgICAgICAgICAgICAgICAgICAgICBieXRlX2N5Y2xlcyA9 IGVuZF9jeWNsZXMgLSBzdGFydF9jeWNsZXM7Cj4gPiArICAgICAgIH0KPiA+ICsKPiA+ICsgICAg ICAga2VybmVsX3ZlY3Rvcl9lbmQoKTsKPiA+ICsKPiA+ICsgICAgICAgLyogRG9uJ3QgZGl2aWRl IGJ5IHplcm8uICovCj4gPiArICAgICAgIGlmICghd29yZF9jeWNsZXMgfHwgIWJ5dGVfY3ljbGVz KSB7Cj4gPiArICAgICAgICAgICAgICAgcHJfd2FybigiY3B1JWQ6IHJkdGltZSBsYWNrcyBncmFu dWxhcml0eSBuZWVkZWQgdG8gbWVhc3VyZSB1bmFsaWduZWQgdmVjdG9yIGFjY2VzcyBzcGVlZFxu IiwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgIGNwdSk7Cj4gPiArCj4gPiArICAgICAgICAg ICAgICAgcmV0dXJuOwo+ID4gKyAgICAgICB9Cj4gPiArCj4gPiArICAgICAgIGlmICh3b3JkX2N5 Y2xlcyA8IGJ5dGVfY3ljbGVzKQo+ID4gKyAgICAgICAgICAgICAgIHNwZWVkID0gUklTQ1ZfSFdQ Uk9CRV9WRUNUT1JfTUlTQUxJR05FRF9GQVNUOwo+ID4gKwo+ID4gKyAgICAgICByYXRpbyA9IGRp dl91NjQoKGJ5dGVfY3ljbGVzICogMTAwKSwgd29yZF9jeWNsZXMpOwo+ID4gKyAgICAgICBwcl9p bmZvKCJjcHUlZDogUmF0aW8gb2YgdmVjdG9yIGJ5dGUgYWNjZXNzIHRpbWUgdG8gdmVjdG9yIHVu YWxpZ25lZCB3b3JkIGFjY2VzcyBpcyAlZC4lMDJkLCB1bmFsaWduZWQgYWNjZXNzZXMgYXJlICVz XG4iLAo+ID4gKyAgICAgICAgICAgICAgIGNwdSwKPiA+ICsgICAgICAgICAgICAgICByYXRpbyAv IDEwMCwKPiA+ICsgICAgICAgICAgICAgICByYXRpbyAlIDEwMCwKPiA+ICsgICAgICAgICAgICAg ICAoc3BlZWQgPT0gIFJJU0NWX0hXUFJPQkVfVkVDVE9SX01JU0FMSUdORURfRkFTVCkgPyAiZmFz dCIgOiAic2xvdyIpOwo+ID4gKwo+ID4gKyAgICAgICBwZXJfY3B1KHZlY3Rvcl9taXNhbGlnbmVk X2FjY2VzcywgY3B1KSA9IHNwZWVkOwo+ID4gK30KPiA+ICsKPiA+ICtzdGF0aWMgaW50IHJpc2N2 X29ubGluZV9jcHVfdmVjKHVuc2lnbmVkIGludCBjcHUpCj4gPiArewo+ID4gKyAgICAgICBjaGVj a192ZWN0b3JfdW5hbGlnbmVkX2FjY2VzcyhOVUxMKTsKPiAKPiBNYXliZSBJIG1pc3NlZCB0aGUg Y2FsbCBzaXRlIGluIGFub3RoZXIgcGF0Y2gsIGJ1dCBhcmUgeW91IGNhbGxpbmcKPiBjaGVja192 ZWN0b3JfdW5hbGlnbmVkX2FjY2Vzc19lbXVsYXRlZCgpIGFueXdoZXJlIGluIHRoZSBob3RwbHVn IHBhdGg/Cj4gV2l0aG91dCB0aGlzLCBmb3IgYSBDUFUgdGhhdCB3YXNuJ3QgcHJlc2VudCBhdCBi b290LCBpdCBzZWVtcyBsaWtlIHRoZQo+IHBlci1jcHUgdmFyaWFibGUgd291bGQgYmUgc2V0IHRv IGl0cyBpbml0aWFsaXplZCB2YWx1ZSBvZiBVTlNVUFBPUlRFRCwKPiBhbmQgdGhlbiB5b3UnZCBi YWlsIGVhcmx5IG91dCBvZiBjaGVja192ZWN0b3JfdW5hbGlnbmVkX2FjY2VzcygpIGF0Cj4gdGhl ICIhPSBTTE9XIiBjb25kaXRpb25hbC4KPiAKPiBJTU8gaXQgd291bGQgYmUgYmV0dGVyIGlmIHRo ZSB2YWx1ZXMgdHJ1bHkgbWVhbnQgd2hhdCB0aGV5IHNhaWQuIFNvIHdlCj4gaW5pdGlhbGl6ZSBp dCB0byBVTktOT1dOLCB1bmNvbmRpdGlvbmFsbHkgY2hhbmdlIHRvIFVOU1VQUE9SVEVEIGlmIHdl Cj4gZGlzY292ZXIgaXQncyBlbXVsYXRlZCBvciB0aGVyZSBpcyBubyB2ZWN0b3Igc3VwcG9ydCwg YW5kIG9ubHkgc2V0IHRvCj4gU0xPVyBvciBGQVNUIGFzIGEgcmVzdWx0IG9mIHByb2JlIG1lYXN1 cmVtZW50IG9yIEtjb25maWcgb3ZlcnJpZGUuCj4gSXQncyB0aGUgIlNMT1cgbWVhbnMgc2xvdyBv ciBkb24ndCBrbm93IiBmcm9tIHRoZSBwcmV2aW91cyBwYXRjaAo+IHRoYXQncyBidWdnaW5nIG1l LiBUaGlzIGNyZWF0ZXMgZG93bnN0cmVhbSBlZmZlY3RzIGxpa2UgdGhpcyAiIT0gU0xPVyIKPiBj b25kaXRpb25hbCAoYnkgd2hpY2ggeW91IHJlYWxseSBtZWFuICIhPSBVTktOT1dOIikgdGhhdCBh cmUKPiBjaGFsbGVuZ2luZyB0byByZWFzb24gYWJvdXQgYW5kIG1haW50YWluLgo+IAo+IEkgaGF2 ZSB0aGlzIHZhZ3VlIHNlbnNlIHRoYXQgeW91IGRpZCB0aGlzIGluIHJlc3BvbnNlIHRvIGZlZWRi YWNrIGluCj4gYW4gZWFybGllciBzZXJpZXMsIGJ1dCBJIGNhbid0IGZpbmQgaXQgbm93LgoKWWVz IHRoZXJlIGhhcyBiZWVuIGEgbG90IG9mIGJhY2sgYW5kIGZvcnRoIG9uIHRoaXMuIEhlcmUgaXMg dGhlIG9yaWdpbmFsCmRpc2N1c3Npb246IGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2xrbWwvWm1O OGdFUjRSbnlveVFUNEBnaG9zdC8uIEkKb3JpZ2luYWxseSBhZ3JlZWQgd2l0aCBDb25vciB0aGF0 IFNMT1cgd291bGQgYmUgcmVhc29uYWJsZSBiZWNhdXNlIGl0CnByZXZlbnRlZCBwcm9ncmFtcyBm cm9tIHJlY2VpdmluZyBhbiBVTktOT1dOIHdoaWNoIHRoZXkgbWF5IGJlIHVuc3VyZQpob3cgdG8g aGFuZGxlLiBUaGUgaWRlYSBoZXJlIGlzIHRoYXQgcHJvZ3JhbXMgdGhhdCByZWx5IG9uIG1pc2Fs aWduZWQKYWNjZXNzIHNwZWVkIHNob3VsZCBhdm9pZCB1c2luZyBtaXNhbGlnbmVkIGFjY2Vzc2Vz IGlmIHRoZSBzcGVlZCBpcwpVTktOT1dOLiBSZXBvcnRpbmcgU0xPVyBpbnN0ZWFkIG9mIFVOS05P V04gdGFrZXMgdGhlIGRlY2lzaW9uIG91dCBvZiB0aGUKaGFuZHMgb2YgdGhlIHByb2dyYW0sIHNv IHRoZXkgZG9uJ3QgaGF2ZSB0byB3b3JyeSBhYm91dCBVTktOT1dOLiBIb3dldmVyCm92ZXIgdGhl IGNvdXJzZSBvZiB0aGlzIHNlcmllcyBJIHRvbyBoYXZlIGJlZW4gaW5jcmVhc2luZ2x5IHVuY29u dmluY2VkCmJ5IHRoaXMgcmVhc29uaW5nLiBJdCBkb2Vzbid0IHNlZW0gbGlrZSB0aGUga2VybmVs J3MgcGxhY2UgdG8gbWFrZSB0aGlzCmRlY2lzaW9uIGZvciB1c2Vyc3BhY2UgYW5kIHNob3VsZCBq dXN0IHByb3ZpZGUgdGhlIGNvcnJlY3QgaW5mb3JtYXRpb24uCgpUaGUgbW9yZSBjb25jcmV0ZSBp c3N1ZSBpcyB3aXRoIENQVSBob3RwbHVnLiBXaGVuIGEgQ1BVIGlzIGhvdHBsdWdnZWQKaW50byBh IG5ldyBDUFUgaW5kZXgsIGl0IHdpbGwgZGVmYXVsdCB0byBVTlNVUFBPUlRFRC4gV2hlbiB0aGUg Q1BVCmVudGVycyBjaGVja192ZWN0b3JfdW5hbGlnbmVkX2FjY2VzcygpLCBpdHMgc3BlZWQgd2ls bCBub3QgYmUgU0xPVyBzbwp0aGUgY29kZSBhc3N1bWVzIGl0IGhhcyBhbHJlYWR5IGJlZW4gcHJv YmVkIC0tIGV2ZW4gdGhvdWdoIGl0IGhhc24ndC4KVGhlIGRlZmF1bHQgc2hvdWxkIGJlIFVOS05P V04gKGluc3RlYWQgb2YgVU5TVVBQT1JURUQpIGFuZCB0aGlzIGNvZGUKc2hvdWxkIGNoZWNrIGZv ciBVTktOT1dOIHRvIGRldGVybWluZSBpZiB0aGUgY3B1IGhhcyBhbHJlYWR5IGJlZW4KcHJvYmVk LgoKV2UgY2FuIHRlc3QgdGhpcyBieSBib290aW5nIExpbnV4IHdpdGggdGhlIGFyZ3VtZW50ICJt YXhjcHVzPTEiIGFuZAphZnRlciBpdCBib290cyBydW46CgojIGVjaG8gMSA+IC9zeXMvZGV2aWNl cy9zeXN0ZW0vY3B1L2NwdTEvb25saW5lClsgICA0MC40ODExNTNdIGNwdTE6IFJhdGlvIG9mIGJ5 dGUgYWNjZXNzIHRpbWUgdG8gdW5hbGlnbmVkIHdvcmQgYWNjZXNzIGlzIDkuMDUsIHVuYWxpZ25l ZCBhY2Nlc3NlcyBhcmUgZmFzdAojCgpPbmx5IHRoZSBzY2FsYXIgbWlzYWxpZ25lZCBhY2Nlc3Mg c3BlZWQgY2hlY2tlciByYW4uIEkgYWxzbyB2ZXJpZmllZAp0aGF0IGNoZWNrX3ZlY3Rvcl91bmFs aWduZWRfYWNjZXNzKCkgc2VlcyB0aGF0IHRoZSBzcGVlZCBpcyBVTktOT1dOCndoaWNoIGlzIG5v dCBTTE9XIHNvIGV4aXRzLgoKLSBDaGFybGllCgo+IAo+IAo+IC1FdmFuCj4gCj4gCj4gPiArICAg ICAgIHJldHVybiAwOwo+ID4gK30KPiA+ICsKPiA+ICsvKiBNZWFzdXJlIHVuYWxpZ25lZCBhY2Nl c3Mgc3BlZWQgb24gYWxsIENQVXMgcHJlc2VudCBhdCBib290IGluIHBhcmFsbGVsLiAqLwo+ID4g K3N0YXRpYyBpbnQgdmVjX2NoZWNrX3VuYWxpZ25lZF9hY2Nlc3Nfc3BlZWRfYWxsX2NwdXModm9p ZCAqdW51c2VkIF9fYWx3YXlzX3VudXNlZCkKPiA+ICt7Cj4gPiArICAgICAgIHNjaGVkdWxlX29u X2VhY2hfY3B1KGNoZWNrX3ZlY3Rvcl91bmFsaWduZWRfYWNjZXNzKTsKPiA+ICsKPiA+ICsgICAg ICAgLyoKPiA+ICsgICAgICAgICogU2V0dXAgaG90cGx1ZyBjYWxsYmFja3MgZm9yIGFueSBuZXcg Q1BVcyB0aGF0IGNvbWUgb25saW5lIG9yIGdvCj4gPiArICAgICAgICAqIG9mZmxpbmUuCj4gPiAr ICAgICAgICAqLwo+ID4gKyAgICAgICBjcHVocF9zZXR1cF9zdGF0ZV9ub2NhbGxzKENQVUhQX0FQ X09OTElORV9EWU4sICJyaXNjdjpvbmxpbmUiLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHJpc2N2X29ubGluZV9jcHVfdmVjLCBOVUxMKTsKPiA+ICsKPiA+ICsgICAgICAg cmV0dXJuIDA7Cj4gPiArfQo+ID4gKyNlbHNlIC8qIENPTkZJR19SSVNDVl9QUk9CRV9WRUNUT1Jf VU5BTElHTkVEX0FDQ0VTUyAqLwo+ID4gK3N0YXRpYyBpbnQgdmVjX2NoZWNrX3VuYWxpZ25lZF9h Y2Nlc3Nfc3BlZWRfYWxsX2NwdXModm9pZCAqdW51c2VkIF9fYWx3YXlzX3VudXNlZCkKPiA+ICt7 Cj4gPiArICAgICAgIHJldHVybiAwOwo+ID4gK30KPiA+ICsjZW5kaWYKPiA+ICsKPiA+ICBzdGF0 aWMgaW50IGNoZWNrX3VuYWxpZ25lZF9hY2Nlc3NfYWxsX2NwdXModm9pZCkKPiA+ICB7Cj4gPiAt ICAgICAgIGJvb2wgYWxsX2NwdXNfZW11bGF0ZWQ7Cj4gPiArICAgICAgIGJvb2wgYWxsX2NwdXNf ZW11bGF0ZWQsIGFsbF9jcHVzX3ZlY191bnN1cHBvcnRlZDsKPiA+Cj4gPiAgICAgICAgIGFsbF9j cHVzX2VtdWxhdGVkID0gY2hlY2tfdW5hbGlnbmVkX2FjY2Vzc19lbXVsYXRlZF9hbGxfY3B1cygp Owo+ID4gLSAgICAgICBjaGVja192ZWN0b3JfdW5hbGlnbmVkX2FjY2Vzc19lbXVsYXRlZF9hbGxf Y3B1cygpOwo+ID4gKyAgICAgICBhbGxfY3B1c192ZWNfdW5zdXBwb3J0ZWQgPSBjaGVja192ZWN0 b3JfdW5hbGlnbmVkX2FjY2Vzc19lbXVsYXRlZF9hbGxfY3B1cygpOwo+ID4gKwo+ID4gKyAgICAg ICBpZiAoIWFsbF9jcHVzX3ZlY191bnN1cHBvcnRlZCAmJgo+ID4gKyAgICAgICAgICAgSVNfRU5B QkxFRChDT05GSUdfUklTQ1ZfUFJPQkVfVkVDVE9SX1VOQUxJR05FRF9BQ0NFU1MpKSB7Cj4gPiAr ICAgICAgICAgICAgICAga3RocmVhZF9ydW4odmVjX2NoZWNrX3VuYWxpZ25lZF9hY2Nlc3Nfc3Bl ZWRfYWxsX2NwdXMsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCwgInZlY19j aGVja191bmFsaWduZWRfYWNjZXNzX3NwZWVkX2FsbF9jcHVzIik7Cj4gPiArICAgICAgIH0KPiA+ Cj4gPiAgICAgICAgIGlmICghYWxsX2NwdXNfZW11bGF0ZWQpCj4gPiAgICAgICAgICAgICAgICAg cmV0dXJuIGNoZWNrX3VuYWxpZ25lZF9hY2Nlc3Nfc3BlZWRfYWxsX2NwdXMoKTsKPiA+IGRpZmYg LS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC92ZWMtY29weS11bmFsaWduZWQuUyBiL2FyY2gvcmlz Y3Yva2VybmVsL3ZlYy1jb3B5LXVuYWxpZ25lZC5TCj4gPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+ ID4gaW5kZXggMDAwMDAwMDAwMDAwLi5kMTZmMTlmMWIzYjYKPiA+IC0tLSAvZGV2L251bGwKPiA+ ICsrKyBiL2FyY2gvcmlzY3Yva2VybmVsL3ZlYy1jb3B5LXVuYWxpZ25lZC5TCj4gPiBAQCAtMCww ICsxLDU4IEBACj4gPiArLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8KPiA+ ICsvKiBDb3B5cmlnaHQgKEMpIDIwMjQgUml2b3MgSW5jLiAqLwo+ID4gKwo+ID4gKyNpbmNsdWRl IDxsaW51eC9hcmdzLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L2xpbmthZ2UuaD4KPiA+ICsjaW5j bHVkZSA8YXNtL2FzbS5oPgo+ID4gKwo+ID4gKyAgICAgICAudGV4dAo+ID4gKwo+ID4gKyNkZWZp bmUgV09SRF9FRVcgMzIKPiA+ICsKPiA+ICsjZGVmaW5lIFdPUkRfU0VXIENPTkNBVEVOQVRFKGUs IFdPUkRfRUVXKQo+ID4gKyNkZWZpbmUgVkVDX0wgQ09OQ0FURU5BVEUodmxlLCBXT1JEX0VFVyku dgo+ID4gKyNkZWZpbmUgVkVDX1MgQ09OQ0FURU5BVEUodmxlLCBXT1JEX0VFVykudgo+ID4gKwo+ ID4gKy8qIHZvaWQgX19yaXNjdl9jb3B5X3ZlY193b3Jkc191bmFsaWduZWQodm9pZCAqLCBjb25z dCB2b2lkICosIHNpemVfdCkgKi8KPiA+ICsvKiBQZXJmb3JtcyBhIG1lbWNweSB3aXRob3V0IGFs aWduaW5nIGJ1ZmZlcnMsIHVzaW5nIHdvcmQgbG9hZHMgYW5kIHN0b3Jlcy4gKi8KPiA+ICsvKiBO b3RlOiBUaGUgc2l6ZSBpcyB0cnVuY2F0ZWQgdG8gYSBtdWx0aXBsZSBvZiBXT1JEX0VFVyAqLwo+ ID4gK1NZTV9GVU5DX1NUQVJUKF9fcmlzY3ZfY29weV92ZWNfd29yZHNfdW5hbGlnbmVkKQo+ID4g KyAgICAgICBhbmRpICBhNCwgYTIsIH4oV09SRF9FRVctMSkKPiA+ICsgICAgICAgYmVxeiAgYTQs IDJmCj4gPiArICAgICAgIGFkZCAgIGEzLCBhMSwgYTQKPiA+ICsgICAgICAgLm9wdGlvbiBwdXNo Cj4gPiArICAgICAgIC5vcHRpb24gYXJjaCwgK3p2ZTMyeAo+ID4gKzE6Cj4gPiArICAgICAgIHZz ZXRpdmxpIHQwLCA4LCBXT1JEX1NFVywgbTgsIHRhLCBtYQo+ID4gKyAgICAgICBWRUNfTCB2MCwg KGExKQo+ID4gKyAgICAgICBWRUNfUyB2MCwgKGEwKQo+ID4gKyAgICAgICBhZGRpICBhMCwgYTAs IFdPUkRfRUVXCj4gPiArICAgICAgIGFkZGkgIGExLCBhMSwgV09SRF9FRVcKPiA+ICsgICAgICAg Ymx0dSAgYTEsIGEzLCAxYgo+ID4gKwo+ID4gKzI6Cj4gPiArICAgICAgIC5vcHRpb24gcG9wCj4g PiArICAgICAgIHJldAo+ID4gK1NZTV9GVU5DX0VORChfX3Jpc2N2X2NvcHlfdmVjX3dvcmRzX3Vu YWxpZ25lZCkKPiA+ICsKPiA+ICsvKiB2b2lkIF9fcmlzY3ZfY29weV92ZWNfYnl0ZXNfdW5hbGln bmVkKHZvaWQgKiwgY29uc3Qgdm9pZCAqLCBzaXplX3QpICovCj4gPiArLyogUGVyZm9ybXMgYSBt ZW1jcHkgd2l0aG91dCBhbGlnbmluZyBidWZmZXJzLCB1c2luZyBvbmx5IGJ5dGUgYWNjZXNzZXMu ICovCj4gPiArLyogTm90ZTogVGhlIHNpemUgaXMgdHJ1bmNhdGVkIHRvIGEgbXVsdGlwbGUgb2Yg OCAqLwo+ID4gK1NZTV9GVU5DX1NUQVJUKF9fcmlzY3ZfY29weV92ZWNfYnl0ZXNfdW5hbGlnbmVk KQo+ID4gKyAgICAgICBhbmRpIGE0LCBhMiwgfig4LTEpCj4gPiArICAgICAgIGJlcXogYTQsIDJm Cj4gPiArICAgICAgIGFkZCAgYTMsIGExLCBhNAo+ID4gKyAgICAgICAub3B0aW9uIHB1c2gKPiA+ ICsgICAgICAgLm9wdGlvbiBhcmNoLCArenZlMzJ4Cj4gPiArMToKPiA+ICsgICAgICAgdnNldGl2 bGkgdDAsIDgsIGU4LCBtOCwgdGEsIG1hCj4gPiArICAgICAgIHZsZTgudiB2MCwgKGExKQo+ID4g KyAgICAgICB2c2U4LnYgdjAsIChhMCkKPiA+ICsgICAgICAgYWRkaSBhMCwgYTAsIDgKPiA+ICsg ICAgICAgYWRkaSBhMSwgYTEsIDgKPiA+ICsgICAgICAgYmx0dSBhMSwgYTMsIDFiCj4gPiArCj4g PiArMjoKPiA+ICsgICAgICAgLm9wdGlvbiBwb3AKPiA+ICsgICAgICAgcmV0Cj4gPiArU1lNX0ZV TkNfRU5EKF9fcmlzY3ZfY29weV92ZWNfYnl0ZXNfdW5hbGlnbmVkKQo+ID4gLS0KPiA+IDIuNDUu Mgo+ID4KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxp bnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0 dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK