Skip to contentSkip to conversation

lib: multiply the max_runtime if detect slow kconfigs

PATCH In review Li Wang 4 participants 24 messages Dec 12, 2024 – Dec 20, 2024 Library code

lore
Share & tools
lore

Li Wang

author
#0 lore raw

PATCH v3 1/1 lib: multiply the max_runtime if detect slow kconfigs

The method adjusts the max_runtime for test cases by multiplying it by a factor (4x) if any slower kernel options are detected. Debug kernel configurations (such as CONFIG_KASAN, CONFIG_PROVE_LOCKING, etc.) are known to degrade performance, and this adjustment ensures that tests do not fail prematurely due to timeouts.

As Cyril pointed out that a debug kernel will typically run slower by a factor of N, and while determining the exact value of N is challenging, so a reasonable upper bound is sufficient for practical purposes.

---
 include/tst_kconfig.h | 13 +++++++++++++
 lib/tst_kconfig.c     | 39 +++++++++++++++++++++++++++++++++++++++
 lib/tst_test.c        |  3 +++
 3 files changed, 55 insertions(+)
include/tst_kconfig.h +13 -0
index 23f807409..291c34b11 100644
@@ -98,4 +98,17 @@ struct tst_kcmdline_var {
  */
 void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len);
 
+/*
+ * Check if any performance-degrading kernel configs are enabled.
+ *
+ * This function iterates over the list of slow kernel configuration options
+ * (`tst_slow_kconfigs`) and checks if any of them are enabled in the running kernel.
+ * These options are known to degrade system performance when enabled.
+ *
+ * Return:
+ * - 1 if at least one slow kernel config is enabled.
+ * - 0 if none of the slow kernel configs are enabled.
+ */
+int tst_has_slow_kconfig(void);
+
 #endif	/* TST_KCONFIG_H__ */
lib/tst_kconfig.c +39 -0
index 6d6b1da18..92c27cb35 100644
@@ -631,3 +631,42 @@ void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len)
 
 	SAFE_FCLOSE(f);
 }
+
+/*
+ * List of kernel config options that may degrade performance when enabled.
+ */
+static struct tst_kconfig_var slow_kconfigs[] = {
+	TST_KCONFIG_INIT("CONFIG_PROVE_LOCKING"),
+	TST_KCONFIG_INIT("CONFIG_LOCKDEP"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_SPINLOCK"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_RT_MUTEXES"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_MUTEXES"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_PAGEALLOC"),
+	TST_KCONFIG_INIT("CONFIG_KASAN"),
+	TST_KCONFIG_INIT("CONFIG_SLUB_RCU_DEBUG"),
+	TST_KCONFIG_INIT("CONFIG_TRACE_IRQFLAGS"),
+	TST_KCONFIG_INIT("CONFIG_LATENCYTOP"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_NET"),
+	TST_KCONFIG_INIT("CONFIG_EXT4_DEBUG"),
+	TST_KCONFIG_INIT("CONFIG_QUOTA_DEBUG"),
+	TST_KCONFIG_INIT("CONFIG_FAULT_INJECTION"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_OBJECTS")
+};
+
+int tst_has_slow_kconfig(void)
+{
+	unsigned int i;
+
+	tst_kconfig_read(slow_kconfigs, ARRAY_SIZE(slow_kconfigs));
+
+	for (i = 0; i < ARRAY_SIZE(slow_kconfigs); i++) {
+		if (slow_kconfigs[i].choice == 'y') {
+			tst_res(TINFO,
+				"%s kernel option detected",
+				slow_kconfigs[i].id);
+			return 1;
+		}
+	}
+
+	return 0;
+}
lib/tst_test.c +3 -0
index 8db554dea..f4e667240 100644
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
 
 	parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
 
+	if (tst_has_slow_kconfig())
+		max_runtime *= 4;
+
 	return max_runtime * runtime_mul;
 }
 
Signature · 5 lines
2.47.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
Reviewed-by on v3 1/1
#1 lore raw

Hi Li,

Quoted 23 lines

The method adjusts the max_runtime for test cases by multiplying it by a factor (4x) if any slower kernel options are detected. Debug kernel configurations (such as CONFIG_KASAN, CONFIG_PROVE_LOCKING, etc.) are known to degrade performance, and this adjustment ensures that tests do not fail prematurely due to timeouts.

As Cyril pointed out that a debug kernel will typically run slower by a factor of N, and while determining the exact value of N is challenging, so a reasonable upper bound is sufficient for practical purposes.

---
 include/tst_kconfig.h | 13 +++++++++++++
 lib/tst_kconfig.c     | 39 +++++++++++++++++++++++++++++++++++++++
 lib/tst_test.c        |  3 +++
 3 files changed, 55 insertions(+)
include/tst_kconfig.h +0 -0
index 23f807409..291c34b11 100644

include/tst_kconfig.h struct tst_kcmdline_var { · line 99

Quoted 2 lines
include/tst_kconfig.h +0 -0
@@ -98,4 +98,17 @@ struct tst_kcmdline_var {
  */
 void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len);

LGTM, few comments below

include/tst_kconfig.h struct tst_kcmdline_var { · line 102

Quoted 2 lines
include/tst_kconfig.h +2 -0
+/*
+ * Check if any performance-degrading kernel configs are enabled.

Could you please before merge change this to:

/**
* tst_has_slow_kconfig() - Check if any performance-degrading kernel configs are enabled.

To comply kernel doc formatting?
tst_kconfig.h has not been added to sphinx doc yet, but it would be nice to add new code with proper formatting.

Kind regards,
Petr

Quoted 21 lines
include/tst_kconfig.h +11 -0
+ *
+ * This function iterates over the list of slow kernel configuration options
+ * (`tst_slow_kconfigs`) and checks if any of them are enabled in the running kernel.
+ * These options are known to degrade system performance when enabled.
+ *
+ * Return:
+ * - 1 if at least one slow kernel config is enabled.
+ * - 0 if none of the slow kernel configs are enabled.
+ */
+int tst_has_slow_kconfig(void);
+
 #endif	/* TST_KCONFIG_H__ */
lib/tst_kconfig.c +1 -0
index 6d6b1da18..92c27cb35 100644
@@ -631,3 +631,42 @@ void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len)
 
 	SAFE_FCLOSE(f);
 }
+

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len) · line 644

Quoted 10 lines
lib/tst_kconfig.c +10 -0
+/*
+ * List of kernel config options that may degrade performance when enabled.
+ */
+static struct tst_kconfig_var slow_kconfigs[] = {
+	TST_KCONFIG_INIT("CONFIG_PROVE_LOCKING"),
+	TST_KCONFIG_INIT("CONFIG_LOCKDEP"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_SPINLOCK"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_RT_MUTEXES"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_MUTEXES"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_PAGEALLOC"),

Does CONFIG_DEBUG_PAGEALLOC itself prolong the run? Isn't it that only when debug_guardpage_minorder=... or debug_pagealloc=... is set?

https://www.kernel.org/doc/html/v5.2/admin-guide/kernel-parameters.html

I would need to run the test with these to see the difference.

Quoted 7 lines
lib/tst_kconfig.c +7 -0
+	TST_KCONFIG_INIT("CONFIG_KASAN"),
+	TST_KCONFIG_INIT("CONFIG_SLUB_RCU_DEBUG"),
+	TST_KCONFIG_INIT("CONFIG_TRACE_IRQFLAGS"),
+	TST_KCONFIG_INIT("CONFIG_LATENCYTOP"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_NET"),
+	TST_KCONFIG_INIT("CONFIG_EXT4_DEBUG"),
+	TST_KCONFIG_INIT("CONFIG_QUOTA_DEBUG"),

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len) · line 661

Quoted 10 lines
lib/tst_kconfig.c +10 -0
+	TST_KCONFIG_INIT("CONFIG_FAULT_INJECTION"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_OBJECTS")
+};
+
+int tst_has_slow_kconfig(void)
+{
+	unsigned int i;
+
+	tst_kconfig_read(slow_kconfigs, ARRAY_SIZE(slow_kconfigs));
+

Maybe here TINFO message "checking for options which slow the execution? Or print it (once) only if option detected? Because it's not obvious why we are detecting it. Or after searching print what we did (4x prolonged runtime).

Quoted 16 lines
lib/tst_kconfig.c +11 -0
+	for (i = 0; i < ARRAY_SIZE(slow_kconfigs); i++) {
+		if (slow_kconfigs[i].choice == 'y') {
+			tst_res(TINFO,
+				"%s kernel option detected",
+				slow_kconfigs[i].id);
+			return 1;
+		}
+	}
+
+	return 0;
+}
lib/tst_test.c +0 -0
index 8db554dea..f4e667240 100644

lib/tst_test.c static int multiply_runtime(int max_runtime) · line 559

Quoted 5 lines
lib/tst_test.c +2 -0
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
 
 	parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
 
+	if (tst_has_slow_kconfig())
+		max_runtime *= 4;

Maybe note here what we do? (TINFO)

Kind regards,
Petr

Quoted 3 lines
lib/tst_test.c +1 -0
+
 	return max_runtime * runtime_mul;
 }
Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#2 lore raw
Quoted 86 lines · Petr Vorel

Hi Li,

Quoted 3 lines

The method adjusts the max_runtime for test cases by multiplying it by a factor (4x) if any slower kernel options are detected. Debug kernel configurations (such as CONFIG_KASAN, CONFIG_PROVE_LOCKING,

etc.)

Quoted 20 lines

are known to degrade performance, and this adjustment ensures that tests do not fail prematurely due to timeouts.

As Cyril pointed out that a debug kernel will typically run slower by a factor of N, and while determining the exact value of N is challenging, so a reasonable upper bound is sufficient for practical purposes.

---
 include/tst_kconfig.h | 13 +++++++++++++
 lib/tst_kconfig.c     | 39 +++++++++++++++++++++++++++++++++++++++
 lib/tst_test.c        |  3 +++
 3 files changed, 55 insertions(+)
include/tst_kconfig.h +0 -0
index 23f807409..291c34b11 100644

include/tst_kconfig.h struct tst_kcmdline_var { · line 99

Quoted 2 lines
include/tst_kconfig.h +0 -0
@@ -98,4 +98,17 @@ struct tst_kcmdline_var {
  */
 void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t

params_len);

LGTM, few comments below

include/tst_kconfig.h struct tst_kcmdline_var { · line 102

Quoted 2 lines
include/tst_kconfig.h +2 -0
+/*
+ * Check if any performance-degrading kernel configs are enabled.

Could you please before merge change this to:

/**
* tst_has_slow_kconfig() - Check if any performance-degrading kernel
configs are enabled.

To comply kernel doc formatting?
tst_kconfig.h has not been added to sphinx doc yet, but it would be nice to add
new code with proper formatting.

Kind regards,
Petr

include/tst_kconfig.h struct tst_kcmdline_var { · line 103

Quoted 2 lines
include/tst_kconfig.h +2 -0
+ *
+ * This function iterates over the list of slow kernel configuration

options

include/tst_kconfig.h struct tst_kcmdline_var { · line 104

Quoted 1 line
include/tst_kconfig.h +1 -0
+ * (`tst_slow_kconfigs`) and checks if any of them are enabled in the

running kernel.

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var

Quoted 14 lines
include/tst_kconfig.h +8 -0
+ * These options are known to degrade system performance when enabled.
+ *
+ * Return:
+ * - 1 if at least one slow kernel config is enabled.
+ * - 0 if none of the slow kernel configs are enabled.
+ */
+int tst_has_slow_kconfig(void);
+
 #endif       /* TST_KCONFIG_H__ */
lib/tst_kconfig.c +0 -0
index 6d6b1da18..92c27cb35 100644
@@ -631,3 +631,42 @@ void tst_kcmdline_parse(struct tst_kcmdline_var

params[], size_t params_len)

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len)

Quoted 5 lines
lib/tst_kconfig.c +3 -0
      SAFE_FCLOSE(f);
 }
+
+/*
+ * List of kernel config options that may degrade performance when

enabled.

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len) · line 644

Quoted 8 lines
lib/tst_kconfig.c +8 -0
+ */
+static struct tst_kconfig_var slow_kconfigs[] = {
+     TST_KCONFIG_INIT("CONFIG_PROVE_LOCKING"),
+     TST_KCONFIG_INIT("CONFIG_LOCKDEP"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_SPINLOCK"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_RT_MUTEXES"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_MUTEXES"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_PAGEALLOC"),
Quoted 3 lines

Does CONFIG_DEBUG_PAGEALLOC itself prolong the run? Isn't it that only when debug_guardpage_minorder=... or debug_pagealloc=... is set?

Good catch.

I guess that won't impact the kernel performance if not set any of the parameters, because from the doc it is disabled by default.

"When CONFIG_DEBUG_PAGEALLOC is set, this parameter enables the feature at boot time. In default, it is disabled.
....
if we don't enable it at boot time and the the system will work mostly same with the kernel built without CONFIG_DEBUG_PAGEALLOC."

So I would like to remove CONFIG_DEBUG_PAGEALLOC from the detecting.

Quoted 4 lines

https://www.kernel.org/doc/html/v5.2/admin-guide/kernel-parameters.html

I would need to run the test with these to see the difference.

Any new found?

Quoted 15 lines
Quoted 15 lines
lib/tst_kconfig.c +13 -0
+     TST_KCONFIG_INIT("CONFIG_KASAN"),
+     TST_KCONFIG_INIT("CONFIG_SLUB_RCU_DEBUG"),
+     TST_KCONFIG_INIT("CONFIG_TRACE_IRQFLAGS"),
+     TST_KCONFIG_INIT("CONFIG_LATENCYTOP"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_NET"),
+     TST_KCONFIG_INIT("CONFIG_EXT4_DEBUG"),
+     TST_KCONFIG_INIT("CONFIG_QUOTA_DEBUG"),
+     TST_KCONFIG_INIT("CONFIG_FAULT_INJECTION"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_OBJECTS")
+};
+
+int tst_has_slow_kconfig(void)
+{
Quoted 9 lines

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len) · line 661

Quoted 4 lines
lib/tst_kconfig.c +4 -0
+     unsigned int i;
+
+     tst_kconfig_read(slow_kconfigs, ARRAY_SIZE(slow_kconfigs));
+

Maybe here TINFO message "checking for options which slow the execution? Or print it (once) only if option detected? Because it's not obvious why we are
detecting it. Or after searching print what we did (4x prolonged runtime).

Agree, the rest comments all look good.

Quoted 31 lines
Quoted 17 lines
lib/tst_kconfig.c +11 -0
+     for (i = 0; i < ARRAY_SIZE(slow_kconfigs); i++) {
+             if (slow_kconfigs[i].choice == 'y') {
+                     tst_res(TINFO,
+                             "%s kernel option detected",
+                             slow_kconfigs[i].id);
+                     return 1;
+             }
+     }
+
+     return 0;
+}
lib/tst_test.c +0 -0
index 8db554dea..f4e667240 100644

lib/tst_test.c static int multiply_runtime(int max_runtime) · line 559

Quoted 5 lines
lib/tst_test.c +2 -0
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
 
      parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
 
+     if (tst_has_slow_kconfig())
+             max_runtime *= 4;

Maybe note here what we do? (TINFO)

Kind regards,
Petr

Quoted 3 lines
lib/tst_test.c +1 -0
+
      return max_runtime * runtime_mul;
 }
Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#3 lore raw

Hi Li,

...

Quoted 19 lines
Quoted 11 lines
Quoted 2 lines

+/*
+ * List of kernel config options that may degrade performance when

enabled.

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len) · line 644

Quoted 8 lines

+ */

lib/tst_kconfig.c +7 -0
+static struct tst_kconfig_var slow_kconfigs[] = {
+     TST_KCONFIG_INIT("CONFIG_PROVE_LOCKING"),
+     TST_KCONFIG_INIT("CONFIG_LOCKDEP"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_SPINLOCK"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_RT_MUTEXES"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_MUTEXES"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_PAGEALLOC"),
Quoted 2 lines

Does CONFIG_DEBUG_PAGEALLOC itself prolong the run? Isn't it that only when debug_guardpage_minorder=... or debug_pagealloc=... is set?

Good catch.

I guess that won't impact the kernel performance if not set any of the parameters, because from the doc it is disabled by default.

Quoted 8 lines

"When CONFIG_DEBUG_PAGEALLOC is set, this parameter enables the feature at boot time. In default, it is disabled.
....
if we don't enable it at boot time and the the system will work mostly same with the kernel built without CONFIG_DEBUG_PAGEALLOC."

So I would like to remove CONFIG_DEBUG_PAGEALLOC from the detecting.

Or maybe to detect if debug_pagealloc kernel cmdline is set with tst_kcmdline_parse()?

OTOH we run with debug_pagealloc=on only syscalls and some long running tests (e.g. bind06) are even slightly faster than when running without it. But that may be affected by QEMU host. Therefore let's skip CONFIG_DEBUG_PAGEALLOC until I find a time to test how it affects the runtime.

Quoted 6 lines
Quoted 3 lines

https://www.kernel.org/doc/html/v5.2/admin-guide/kernel-parameters.html

I would need to run the test with these to see the difference.

Any new found?

I'm sorry I haven't tested yet. Feel free to not to wait and merge. I'll try to do it soon.

Kind regards,
Petr

Quoted 23 lines
Quoted 13 lines
Quoted 13 lines
lib/tst_kconfig.c +13 -0
+     TST_KCONFIG_INIT("CONFIG_KASAN"),
+     TST_KCONFIG_INIT("CONFIG_SLUB_RCU_DEBUG"),
+     TST_KCONFIG_INIT("CONFIG_TRACE_IRQFLAGS"),
+     TST_KCONFIG_INIT("CONFIG_LATENCYTOP"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_NET"),
+     TST_KCONFIG_INIT("CONFIG_EXT4_DEBUG"),
+     TST_KCONFIG_INIT("CONFIG_QUOTA_DEBUG"),
+     TST_KCONFIG_INIT("CONFIG_FAULT_INJECTION"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_OBJECTS")
+};
+
+int tst_has_slow_kconfig(void)
+{
Quoted 8 lines

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len) · line 661

Quoted 4 lines
lib/tst_kconfig.c +4 -0
+     unsigned int i;
+
+     tst_kconfig_read(slow_kconfigs, ARRAY_SIZE(slow_kconfigs));
+

Maybe here TINFO message "checking for options which slow the execution? Or print it (once) only if option detected? Because it's not obvious why we are
detecting it. Or after searching print what we did (4x prolonged runtime).

Quoted 1 line

Agree, the rest comments all look good.

+1

Kind regards,
Petr

Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#4 lore raw
Quoted 29 lines · Petr Vorel

Hi Li,

...

Quoted 11 lines
Quoted 11 lines
Quoted 2 lines

+/*
+ * List of kernel config options that may degrade performance when

enabled.

Quoted 8 lines

+ */

lib/tst_kconfig.c +7 -0
+static struct tst_kconfig_var slow_kconfigs[] = {
+     TST_KCONFIG_INIT("CONFIG_PROVE_LOCKING"),
+     TST_KCONFIG_INIT("CONFIG_LOCKDEP"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_SPINLOCK"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_RT_MUTEXES"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_MUTEXES"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_PAGEALLOC"),
Quoted 1 line
Quoted 1 line

Does CONFIG_DEBUG_PAGEALLOC itself prolong the run? Isn't it that only

when

Quoted 12 lines
Quoted 1 line

debug_guardpage_minorder=... or debug_pagealloc=... is set?

Good catch.

I guess that won't impact the kernel performance if not set any of the parameters, because from the doc it is disabled by default.

"When CONFIG_DEBUG_PAGEALLOC is set, this parameter enables the feature at boot time. In default, it is disabled.
....
if we don't enable it at boot time and the the system will work mostly same with the kernel built without CONFIG_DEBUG_PAGEALLOC."

Quoted 6 lines
Quoted 2 lines

So I would like to remove CONFIG_DEBUG_PAGEALLOC from the detecting.

Or maybe to detect if debug_pagealloc kernel cmdline is set with tst_kcmdline_parse()?

Ok, later we can do that in a separate patch by adding a slow_params[]. Using another function like tst_has_slow_param() should be similar with this method just detecting the slow kcmdlines.

Quoted 9 lines

OTOH we run with debug_pagealloc=on only syscalls and some long running tests
(e.g. bind06) are even slightly faster than when running without it. But that
may be affected by QEMU host. Therefore let's skip CONFIG_DEBUG_PAGEALLOC until
I find a time to test how it affects the runtime.

Thanks, I don't think it's helpful to detect configurations that are not always enabled. We typically test the general or debug kernel in the productive environment but do not often test with specific debug kernel configures.

But I keep an open mind if we need to add more fine-grained testing controls in the future.

Quoted 51 lines
Quoted 2 lines
Quoted 2 lines

https://www.kernel.org/doc/html/v5.2/admin-guide/kernel-parameters.html

Quoted 4 lines
Quoted 1 line

I would need to run the test with these to see the difference.

Any new found?

I'm sorry I haven't tested yet. Feel free to not to wait and merge. I'll try to
do it soon.

Kind regards,
Petr

Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
lib/tst_kconfig.c +10 -0
+     TST_KCONFIG_INIT("CONFIG_KASAN"),
+     TST_KCONFIG_INIT("CONFIG_SLUB_RCU_DEBUG"),
+     TST_KCONFIG_INIT("CONFIG_TRACE_IRQFLAGS"),
+     TST_KCONFIG_INIT("CONFIG_LATENCYTOP"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_NET"),
+     TST_KCONFIG_INIT("CONFIG_EXT4_DEBUG"),
+     TST_KCONFIG_INIT("CONFIG_QUOTA_DEBUG"),
+     TST_KCONFIG_INIT("CONFIG_FAULT_INJECTION"),
+     TST_KCONFIG_INIT("CONFIG_DEBUG_OBJECTS")
+};
Quoted 8 lines
Quoted 8 lines

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len) · line 661

Quoted 7 lines
lib/tst_kconfig.c +7 -0
+
+int tst_has_slow_kconfig(void)
+{
+     unsigned int i;
+
+     tst_kconfig_read(slow_kconfigs, ARRAY_SIZE(slow_kconfigs));
+

Maybe here TINFO message "checking for options which slow the

execution?

Quoted 1 line
Quoted 1 line

Or print it (once) only if option detected? Because it's not obvious

why

Quoted 2 lines
Quoted 2 lines

we are
detecting it. Or after searching print what we did (4x prolonged

runtime).

Quoted 1 line

Agree, the rest comments all look good.

+1

Kind regards,
Petr

Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#5 lore raw
In reply to Petr Vorel

Hi!

Quoted 38 lines
Quoted 7 lines
lib/tst_kconfig.c +7 -0
+	TST_KCONFIG_INIT("CONFIG_KASAN"),
+	TST_KCONFIG_INIT("CONFIG_SLUB_RCU_DEBUG"),
+	TST_KCONFIG_INIT("CONFIG_TRACE_IRQFLAGS"),
+	TST_KCONFIG_INIT("CONFIG_LATENCYTOP"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_NET"),
+	TST_KCONFIG_INIT("CONFIG_EXT4_DEBUG"),
+	TST_KCONFIG_INIT("CONFIG_QUOTA_DEBUG"),

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len) · line 661

Quoted 10 lines
lib/tst_kconfig.c +10 -0
+	TST_KCONFIG_INIT("CONFIG_FAULT_INJECTION"),
+	TST_KCONFIG_INIT("CONFIG_DEBUG_OBJECTS")
+};
+
+int tst_has_slow_kconfig(void)
+{
+	unsigned int i;
+
+	tst_kconfig_read(slow_kconfigs, ARRAY_SIZE(slow_kconfigs));
+

Maybe here TINFO message "checking for options which slow the execution? Or print it (once) only if option detected? Because it's not obvious why we are detecting it. Or after searching print what we did (4x prolonged runtime).

Quoted 16 lines
lib/tst_kconfig.c +11 -0
+	for (i = 0; i < ARRAY_SIZE(slow_kconfigs); i++) {
+		if (slow_kconfigs[i].choice == 'y') {
+			tst_res(TINFO,
+				"%s kernel option detected",
+				slow_kconfigs[i].id);
+			return 1;
+		}
+	}
+
+	return 0;
+}
lib/tst_test.c +0 -0
index 8db554dea..f4e667240 100644
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
Quoted 5 lines

lib/tst_test.c static int multiply_runtime(int max_runtime) · line 559

Quoted 4 lines
lib/tst_test.c +2 -0
 	parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
 
+	if (tst_has_slow_kconfig())
+		max_runtime *= 4;

Maybe note here what we do? (TINFO)

That really depends on how verbose we want to be, we already print the overall test timeout which is timeout + runtime. So it's somehow visible in the test runtime has been increased. Maybe we should make the info message in set_timeout() better by printing the runtime separately there if non-zero.

Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#6 lore raw

Hi all,

...

Quoted 9 lines
Quoted 3 lines

lib/tst_test.c static int multiply_runtime(int max_runtime) · line 559

Quoted 2 lines
lib/tst_test.c +2 -0
+	if (tst_has_slow_kconfig())
+		max_runtime *= 4;

Maybe note here what we do? (TINFO)

That really depends on how verbose we want to be, we already print the overall test timeout which is timeout + runtime. So it's somehow visible in the test runtime has been increased. Maybe we should make the info message in set_timeout() better by printing the runtime separately there if non-zero.

Sounds useful to me.

Kind regards,
Petr

Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#7 lore raw
In reply to Cyril Hrubis
Quoted 45 lines · Cyril Hrubis

Hi!

Quoted 11 lines
Quoted 11 lines
lib/tst_kconfig.c +11 -0
+   TST_KCONFIG_INIT("CONFIG_KASAN"),
+   TST_KCONFIG_INIT("CONFIG_SLUB_RCU_DEBUG"),
+   TST_KCONFIG_INIT("CONFIG_TRACE_IRQFLAGS"),
+   TST_KCONFIG_INIT("CONFIG_LATENCYTOP"),
+   TST_KCONFIG_INIT("CONFIG_DEBUG_NET"),
+   TST_KCONFIG_INIT("CONFIG_EXT4_DEBUG"),
+   TST_KCONFIG_INIT("CONFIG_QUOTA_DEBUG"),
+   TST_KCONFIG_INIT("CONFIG_FAULT_INJECTION"),
+   TST_KCONFIG_INIT("CONFIG_DEBUG_OBJECTS")
+};
+
Quoted 8 lines

lib/tst_kconfig.c void tst_kcmdline_parse(struct tst_kcmdline_var params[], size_t params_len) · line 661

Quoted 6 lines
lib/tst_kconfig.c +6 -0
+int tst_has_slow_kconfig(void)
+{
+   unsigned int i;
+
+   tst_kconfig_read(slow_kconfigs, ARRAY_SIZE(slow_kconfigs));
+

Maybe here TINFO message "checking for options which slow the execution? Or print it (once) only if option detected? Because it's not obvious why

we are

Quoted 1 line

detecting it. Or after searching print what we did (4x prolonged

runtime).

Quoted 22 lines
Quoted 22 lines
lib/tst_kconfig.c +11 -0
+   for (i = 0; i < ARRAY_SIZE(slow_kconfigs); i++) {
+           if (slow_kconfigs[i].choice == 'y') {
+                   tst_res(TINFO,
+                           "%s kernel option detected",
+                           slow_kconfigs[i].id);
+                   return 1;
+           }
+   }
+
+   return 0;
+}
lib/tst_test.c +2 -0
index 8db554dea..f4e667240 100644
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
 
    parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
 
+   if (tst_has_slow_kconfig())
+           max_runtime *= 4;
Quoted 8 lines
Quoted 1 line

Maybe note here what we do? (TINFO)

That really depends on how verbose we want to be, we already print the overall test timeout which is timeout + runtime. So it's somehow visible in the test runtime has been increased. Maybe we should make the info message in set_timeout() better by printing the runtime separately there if non-zero.

You mean we add one line print for the max_runtime separately? That might be so verbose that sometimes the test invokes tst_set_max_runtime()it will print twice in the logs.

# ./starvation
tst_tmpdir.c:316: TINFO: Using /tmp/LTP_staVoNT4a as tmpdir (xfs filesystem)
tst_test.c:1896: TINFO: LTP version: 20240930
tst_test.c:1900: TINFO: Tested kernel:
5.14.0-539.5812_1580643863.el9.x86_64 #1 SMP PREEMPT_DYNAMIC Mon Dec 9
18:03:26 UTC 2024 x86_64
tst_test.c:1731: TINFO: Timeout per run is 0h 00m 30s
starvation.c:98: TINFO: Setting affinity to CPU 0
starvation.c:52: TINFO: CPU did 120000000 loops in 75292us
tst_kconfig.c:88: TINFO: Parsing kernel config
'/lib/modules/5.14.0-539.5812_1580643863.el9.x86_64/build/.config'
tst_test.c:1739: TINFO: Updating max runtime to 0h 01m 15s
tst_test.c:1729: TINFO: Max_runtime is set to 75 seconds
tst_test.c:1731: TINFO: Timeout per run is 0h 01m 45s
starvation.c:150: TPASS: Haven't reproduced scheduller starvation.

Summary:

passed   1
failed   0
broken   0
skipped  0

warnings 0

Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#8 lore raw

I only pushed the patch + Petr's suggestion. Let's see how it goes in the coming test.

Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#10 lore raw
In reply to Li Wang

Hi Li,

...

lib/tst_test.c static int multiply_runtime(int max_runtime) · line 559

Quoted 7 lines

+++ b/lib/tst_test.c

lib/tst_test.c +2 -0
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
 
 	parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
 
+	if (tst_has_slow_kconfig())
+		max_runtime *= 4;

FYI this change prolongs some fuzzy sync tests, e.g. setsockopt06 or writev03. I guess this is a side effect, or not? Or does slow machine really needs to run longer in order to trigger bug in fuzzy sync?

We have 900 sec timeout in openQA (default LTP timeout is 600 sec), but it's not enough. Sure, the solution is to increase it to 2400 (4*600), but then we need really to have more precise .max_runtime setup otherwise tests which got stuck will prolong testing 4x times.

This is for syscalls, I haven't checked other runtests (specially these which have high .max_runtime, e.g. ltp-aio-stress).

Kind regards,
Petr

Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#11 lore raw
Quoted 8 lines · Petr Vorel

Hi Li,

...

Quoted 4 lines

+++ b/lib/tst_test.c

lib/tst_test.c +0 -0
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
 
      parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
Quoted 9 lines

lib/tst_test.c static int multiply_runtime(int max_runtime) · line 559

Quoted 2 lines
lib/tst_test.c +2 -0
+     if (tst_has_slow_kconfig())
+             max_runtime *= 4;

FYI this change prolongs some fuzzy sync tests, e.g. setsockopt06 or writev03.
I guess this is a side effect, or not? Or does slow machine really needs to run
longer in order to trigger bug in fuzzy sync?

Yes, that will prolong the fuzzy test on debug-kernel but fortunately fuzzy has
'pair->exec_loops' to control the total test numbers. It wouldn't prolong too
long I guess.

For the test which keeps looping until they run out of runtime (Martin pointed)
we need to come up with a way to limit the runtime. I need to go though and see
how many they are.

Quoted 16 lines

We have 900 sec timeout in openQA (default LTP timeout is 600 sec), but it's not enough.
Sure, the solution is to increase it to 2400 (4*600), but then we need really to
have more precise .max_runtime setup otherwise tests which got stuck will prolong testing 4x times.

This is for syscalls, I haven't checked other runtests (specially these which
have high .max_runtime, e.g. ltp-aio-stress).

Kind regards,
Petr

Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#12 lore raw
In reply to Li Wang

Hi!

Quoted 25 lines · Li Wang

The method adjusts the max_runtime for test cases by multiplying it by a factor (4x) if any slower kernel options are detected. Debug kernel configurations (such as CONFIG_KASAN, CONFIG_PROVE_LOCKING, etc.) are known to degrade performance, and this adjustment ensures that tests do not fail prematurely due to timeouts.

As Cyril pointed out that a debug kernel will typically run slower by a factor of N, and while determining the exact value of N is challenging, so a reasonable upper bound is sufficient for practical purposes.

---
  include/tst_kconfig.h | 13 +++++++++++++
  lib/tst_kconfig.c     | 39 +++++++++++++++++++++++++++++++++++++++
  lib/tst_test.c        |  3 +++
  3 files changed, 55 insertions(+)

<snip>

lib/tst_test.c +0 -0
index 8db554dea..f4e667240 100644

lib/tst_test.c static int multiply_runtime(int max_runtime) · line 563

Quoted 9 lines
lib/tst_test.c +3 -0
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
 
  	parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
 
+	if (tst_has_slow_kconfig())
+		max_runtime *= 4;
+
  	return max_runtime * runtime_mul;
  }
 

We have plenty of tests which keep looping until they run out of runtime and then automatically stop. These tests are not at risk of timing out and this patch only makes them run 3 times longer than necessary.

I'd recommend temporarily reverting this patch and adding it back with a new tst_test flag to identify tests which exit when runtime expires.

Signature · 10 lines
Martin Doucha   [email protected]
SW Quality Engineer
SUSE LINUX, s.r.o.
CORSO IIa
Krizikova 148/34
186 00 Prague 8
Czech Republic

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#13 lore raw
Quoted 39 lines

Hi!

Quoted 25 lines · Li Wang

The method adjusts the max_runtime for test cases by multiplying it by a factor (4x) if any slower kernel options are detected. Debug kernel configurations (such as CONFIG_KASAN, CONFIG_PROVE_LOCKING, etc.) are known to degrade performance, and this adjustment ensures that tests do not fail prematurely due to timeouts.

As Cyril pointed out that a debug kernel will typically run slower by a factor of N, and while determining the exact value of N is challenging, so a reasonable upper bound is sufficient for practical purposes.

---
  include/tst_kconfig.h | 13 +++++++++++++
  lib/tst_kconfig.c     | 39 +++++++++++++++++++++++++++++++++++++++
  lib/tst_test.c        |  3 +++
  3 files changed, 55 insertions(+)

<snip>

lib/tst_test.c +0 -0
index 8db554dea..f4e667240 100644

lib/tst_test.c static int multiply_runtime(int max_runtime) · line 560

Quoted 6 lines
lib/tst_test.c +3 -0
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
  	parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
+	if (tst_has_slow_kconfig())
+		max_runtime *= 4;
+
  	return max_runtime * runtime_mul;
  }

We have plenty of tests which keep looping until they run out of runtime and then automatically stop. These tests are not at risk of timing out and this patch only makes them run 3 times longer than necessary.

Quoted 2 lines

I'd recommend temporarily reverting this patch and adding it back with a new tst_test flag to identify tests which exit when runtime expires.

+1. Li, could you please do it?

Kind regards,
Petr

Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#14 lore raw
Quoted 37 lines · Petr Vorel
Quoted 6 lines

Hi!

Quoted 3 lines · Li Wang

The method adjusts the max_runtime for test cases by multiplying it by a factor (4x) if any slower kernel options are detected. Debug kernel configurations (such as CONFIG_KASAN,

CONFIG_PROVE_LOCKING, etc.)

Quoted 17 lines
Quoted 16 lines

are known to degrade performance, and this adjustment ensures that tests do not fail prematurely due to timeouts.

As Cyril pointed out that a debug kernel will typically run slower by a factor of N, and while determining the exact value of N is challenging, so a reasonable upper bound is sufficient for practical purposes.

---
  include/tst_kconfig.h | 13 +++++++++++++
  lib/tst_kconfig.c     | 39 +++++++++++++++++++++++++++++++++++++++
  lib/tst_test.c        |  3 +++
  3 files changed, 55 insertions(+)

<snip>

Quoted 13 lines

lib/tst_test.c static int multiply_runtime(int max_runtime) · line 560

Quoted 11 lines
lib/tst_test.c +3 -0
index 8db554dea..f4e667240 100644
@@ -555,6 +555,9 @@ static int multiply_runtime(int max_runtime)
    parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
+   if (tst_has_slow_kconfig())
+           max_runtime *= 4;
+
    return max_runtime * runtime_mul;
  }

We have plenty of tests which keep looping until they run out of runtime

Quoted 5 lines

and

Quoted 1 line

then automatically stop. These tests are not at risk of timing out and

this

Quoted 1 line

patch only makes them run 3 times longer than necessary.

We can bypass the multiply when recognizing those test.

Quoted 7 lines
Quoted 2 lines

I'd recommend temporarily reverting this patch and adding it back with a

new

Quoted 1 line

tst_test flag to identify tests which exit when runtime expires.

+1. Li, could you please do it?

Sure, but I am wondering do you running the latest LTP branch in productive env?
If so I am sorry to make the test time prolong.
Or if not, could you give me a period to resolve it in a new patch?

Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#15 lore raw

Hi Li, all,

Quoted 6 lines · Petr Vorel
Quoted 2 lines

+1. Li, could you please do it?

Sure, but I am wondering do you running the latest LTP branch in productive env?

We mostly run LTP stable branch with some exceptions: openSUSE Tumbleweed and few products in development. Usually it would be more work to backport fixes to stable package than running master. But sometimes we get a punishment for this approach :).

Quoted 2 lines

If so I am sorry to make the test time prolong.
Or if not, could you give me a period to resolve it in a new patch?

Sure.

Kind regards,
Petr

Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
#16 lore raw

Hi!

Quoted 7 lines
Quoted 2 lines

Sure, but I am wondering do you running the latest LTP branch in productive env?

We mostly run LTP stable branch with some exceptions: openSUSE Tumbleweed and few products in development. Usually it would be more work to backport fixes to stable package than running master. But sometimes we get a punishment for this approach :).

It's also best CI for LTP.

Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#17 lore raw

Hi All,

It suddenly occurred to me that we might be on the wrong track in solving the timeout problem. Because 'max_runtime' is intended to set the expected runtime for the main part of the test, and is also used as the loop termination time by tst_remaining_time(). So the multiplier has a side effect of extending the looping time of many tests.

But our original intention was to avoid test timeouts on slow systems (e.g. debug kernels), and the timeout is a hard upper bound to prevent the test from hanging indefinitely due to environmental factors (e.g., slow systems, kernel debug mode).

So, shouldn't we only target to extend the timeout value?

lib/tst_test.c +0 -3
@@ -555,9 +555,6 @@ static int multiply_runtime(int max_runtime)
 
        parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
 
-       if (tst_has_slow_kconfig())
-               max_runtime *= 4;
-
        return max_runtime * runtime_mul;
 }
 
@@ -1706,6 +1703,9 @@ unsigned int tst_multiply_timeout(unsigned int

timeout)
if (timeout < 1)
tst_brk(TBROK, "timeout must to be >= 1! (%d)", timeout);

+ if (tst_has_slow_kconfig())
+ timeout *= 4;
+

        return timeout * timeout_mul;

}

Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#18 lore raw
Quoted 30 lines · Li Wang

Hi All,

It suddenly occurred to me that we might be on the wrong track in solving the timeout problem. Because 'max_runtime' is intended to set the expected runtime for the main part of the test, and is also used as the loop termination time by tst_remaining_time(). So the multiplier has a side effect of extending the looping time of many tests.

But our original intention was to avoid test timeouts on slow systems (e.g. debug kernels), and the timeout is a hard upper bound to prevent the test from hanging indefinitely due to environmental factors (e.g., slow systems, kernel debug mode).

So, shouldn't we only target to extend the timeout value?

lib/tst_test.c +0 -3
@@ -555,9 +555,6 @@ static int multiply_runtime(int max_runtime)
 
        parse_mul(&runtime_mul, "LTP_RUNTIME_MUL", 0.0099, 100);
 
-       if (tst_has_slow_kconfig())
-               max_runtime *= 4;
-
        return max_runtime * runtime_mul;
 }
 

lib/tst_test.c unsigned int tst_multiply_timeout(unsigned int · line 1711

Quoted 9 lines
lib/tst_test.c +3 -0
@@ -1706,6 +1703,9 @@ unsigned int tst_multiply_timeout(unsigned int
 timeout)
        if (timeout < 1)
                tst_brk(TBROK, "timeout must to be >= 1! (%d)", timeout);
 
+       if (tst_has_slow_kconfig())
+               timeout *= 4;
+
        return timeout * timeout_mul;
 }

Regarding the starvation.c test, is not a common issue, the test using max_runtime to complete 1000000 loops in such required time slot to judge FAIL or PASS is not perfect, while the debug kernel will throw a false positive once the runtime is not enough for looping.

It's not about finding the right max_runtime value for all scenarios, which interferes with our sight. Because their callibrate() doesn't have much difference from general or debug kernel evaluation, it only relies on CPU models.

We can treat it as a dedicated case or skip from debug-kernel directly.

Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#19 lore raw
In reply to Martin Doucha

Hi!

Quoted 6 lines

We have plenty of tests which keep looping until they run out of runtime and then automatically stop. These tests are not at risk of timing out and this patch only makes them run 3 times longer than necessary.

I'd recommend temporarily reverting this patch and adding it back with a new tst_test flag to identify tests which exit when runtime expires.

Sounds like we need to have two different runtime values in the tests, max_runtime which is the timeout for the test and just runtime which is for how long will the test loop.

And for the test that loop for a given runtime the max_runtime would be automatically set to the runtime in the test library.

Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#20 lore raw
Quoted 5 lines · Cyril Hrubis

Hi!

Quoted 4 lines

We have plenty of tests which keep looping until they run out of runtime and then automatically stop. These tests are not at risk of timing out and this patch only makes them run 3 times longer than necessary.

Quoted 7 lines
Quoted 2 lines

I'd recommend temporarily reverting this patch and adding it back with a new tst_test flag to identify tests which exit when runtime expires.

Sounds like we need to have two different runtime values in the tests, max_runtime which is the timeout for the test and just runtime which is for how long will the test loop.

Agree, if we define the looping runtime in a separate value, that would be helpful.

Quoted 8 lines

And for the test that loop for a given runtime the max_runtime would be automatically set to the runtime in the test library.

--
Cyril Hrubis
[email protected]

Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#21 lore raw

Hi!

Quoted 7 lines
Quoted 4 lines

Sounds like we need to have two different runtime values in the tests, max_runtime which is the timeout for the test and just runtime which is for how long will the test loop.

Agree, if we define the looping runtime in a separate value, that would be helpful.

There was a problem with having the two different values in a single variable before as well. We do have the LTP_RUNTIME_MUL which multiplied both the timeout and runtime. These should be separate multipliers as well which multiplied both the timeout and runtime. These should be separate multipliers as well.

Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#22 lore raw
Quoted 7 lines · Cyril Hrubis

Hi!

Quoted 6 lines
Quoted 4 lines

Sounds like we need to have two different runtime values in the tests, max_runtime which is the timeout for the test and just runtime which is for how long will the test loop.

Agree, if we define the looping runtime in a separate value, that would

Quoted 9 lines

be

Quoted 1 line

helpful.

There was a problem with having the two different values in a single variable before as well. We do have the LTP_RUNTIME_MUL which multiplied both the timeout and runtime. These should be separate multipliers as well which multiplied both the timeout and runtime. These should be separate multipliers as well.

I noticed that tests using max_runtime to control the test time always use another function tst_remaining_runtime(), so maybe we can utilize this to bypass that.

Later I will look into details, now I have a meeting in the coming 2h.

@Petr, @Martin, Feel free to revert the two patches if you needed. 2da30df24e676d5f4cfcf0b11674cbdf11a19b8a 64e11fec079480179aa9473ae5e1e8ad78ef9ac3

Quoted 6 lines

--
Cyril Hrubis
[email protected]

Signature · 5 lines
Regards,
Li Wang

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#23 lore raw
Quoted 23 lines · Cyril Hrubis
Quoted 8 lines

Hi!

Quoted 6 lines
Quoted 3 lines

Sounds like we need to have two different runtime values in the tests, max_runtime which is the timeout for the test and just runtime which is for how long will the test loop.

Agree, if we define the looping runtime in a separate value, that would

Quoted 8 lines

be

Quoted 1 line

helpful.

There was a problem with having the two different values in a single variable before as well. We do have the LTP_RUNTIME_MUL which multiplied both the timeout and runtime. These should be separate multipliers as well which multiplied both the timeout and runtime. These should be separate multipliers as well.

I noticed that tests using max_runtime to control the test time always use another function tst_remaining_runtime(), so maybe we can utilize this to bypass that.

Quoted 5 lines

Later I will look into details, now I have a meeting in the coming 2h.

@Petr, @Martin, Feel free to revert the two patches if you needed. 2da30df24e676d5f4cfcf0b11674cbdf11a19b8a 64e11fec079480179aa9473ae5e1e8ad78ef9ac3

Thanks. OK, we can wait a bit (few days) until revert. There will be Xmas, thus not much busy time for us.

Kind regards,
Petr

Quoted 3 lines
Quoted 3 lines

--
Cyril Hrubis
[email protected]

Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp