Sched-tools

sched-tools@lists.linaro.org

94 discussions

[PATCH V2] rt-app: Fix broken 'loop' default value

by Viresh Kumar

According to documentation the default value of 'loop' is -1, but the threads without a loop field runs only once and stops. Fix it. Fixes: 3bda96e6e664 ("add phase feature") Signed-off-by: Viresh Kumar <viresh.kumar(a)linaro.org> --- V2: Fixed at a different place and updated Fixes tag as well. src/rt-app_parse_config.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/rt-app_parse_config.c b/src/rt-app_parse_config.c index e5ef87f6ee3e..f06b32162b20 100644 --- a/src/rt-app_parse_config.c +++ b/src/rt-app_parse_config.c @@ -734,7 +734,7 @@ parse_thread_data(char *name, struct json_object *obj, int index, data->phases = malloc(sizeof(phase_data_t) * data->nphases); parse_thread_phase_data(obj, &data->phases[0], opts, (long)data); /* Get loop number */ - data->loop = 1; + data->loop = -1; } } -- 2.7.1.410.g6faf27b

7 years, 2 months

[PATCH] rt-app: Fix broken 'loop' default value

by Viresh Kumar

According to documentation the default value of 'loop' is -1, but the threads without a loop field runs only once and stops. This was broken long back, perhaps unintentionally though. Fix it. Fixes: 82dae3e5ee2f ("simplify the grammar") Signed-off-by: Viresh Kumar <viresh.kumar(a)linaro.org> --- src/rt-app_parse_config.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/rt-app_parse_config.c b/src/rt-app_parse_config.c index e5ef87f6ee3e..96bd2d299389 100644 --- a/src/rt-app_parse_config.c +++ b/src/rt-app_parse_config.c @@ -605,7 +605,7 @@ parse_thread_phase_data(struct json_object *obj, int i; /* loop */ - data->loop = get_int_value_from(obj, "loop", TRUE, 1); + data->loop = get_int_value_from(obj, "loop", TRUE, -1); /* Count number of events */ data->nbevents = 0; -- 2.7.1.410.g6faf27b

7 years, 2 months

[PATCH] rtapp: Add broader support for specifying cpusets

by Stephen Boyd

From: Olav Haugan <ohaugan(a)codeaurora.org> Allow setting of cpusets at all levels of the spec. Signed-off-by: Olav Haugan <ohaugan(a)codeaurora.org> Signed-off-by: Stephen Boyd <stephen.boyd(a)linaro.org> --- src/rt-app.c | 119 ++++++++++++++++++++++++++++++++++++++++------ src/rt-app_parse_config.c | 62 +++++++++++++++--------- src/rt-app_types.h | 12 ++++- 3 files changed, 155 insertions(+), 38 deletions(-) diff --git a/src/rt-app.c b/src/rt-app.c index 0f992f5748c4..50922aa2ee03 100644 --- a/src/rt-app.c +++ b/src/rt-app.c @@ -448,6 +448,109 @@ shutdown(int sig) exit(EXIT_SUCCESS); } +static void create_cpuset_str(cpu_data_t *cpu_data) +{ + unsigned int cpu_count = CPU_COUNT_S(cpu_data->cpusetsize, + cpu_data->cpuset); + unsigned int i; + unsigned int idx = 0; + + /* Assume we can go up to 9999 cpus. Each cpu would take up to 4 + 2 + * bytes (4 for the number and 2 for the comma and space). 2 bytes + * for beginning bracket + space and 2 bytes for end bracket and space + * and finally null-terminator. + */ + unsigned int size_needed = cpu_count * 6 + 2 + 2 + 1; + + cpu_data->cpuset_str = malloc(size_needed); + strcpy(cpu_data->cpuset_str, "[ "); + idx += 2; + + for (i = 0; i < 10000 && cpu_count; ++i) { + unsigned int n; + + if (CPU_ISSET(i, cpu_data->cpuset)) { + --cpu_count; + if (size_needed <= (idx + 1)) { + log_error("Not enough memory for array"); + exit(EXIT_FAILURE); + } + n = snprintf(&cpu_data->cpuset_str[idx], + size_needed - idx - 1, "%d", i); + if (n > 0) { + idx += n; + } else { + log_error("Error creating array"); + exit(EXIT_FAILURE); + } + if (size_needed <= (idx + 1)) { + log_error("Not enough memory for array"); + exit(EXIT_FAILURE); + } + if (cpu_count) { + strncat(cpu_data->cpuset_str, ", ", + size_needed - idx - 1); + idx += 2; + } + } + } + strncat(cpu_data->cpuset_str, " ]", size_needed - idx - 1); +} + +static void set_thread_affinity(thread_data_t *data, cpu_data_t *cpu_data) +{ + int ret; + cpu_data_t *actual_cpu_data = &data->cpu_data; + + if (data->def_cpu_data.cpuset == NULL) { + /* Get default affinity */ + cpu_set_t cpuset; + unsigned int cpu_count; + unsigned int cpu = 0; + + ret = pthread_getaffinity_np(pthread_self(), + sizeof(cpu_set_t), &cpuset); + if (ret != 0) { + errno = ret; + perror("pthread_get_affinity"); + exit(EXIT_FAILURE); + } + cpu_count = CPU_COUNT(&cpuset); + data->def_cpu_data.cpusetsize = CPU_ALLOC_SIZE(cpu_count); + data->def_cpu_data.cpuset = CPU_ALLOC(cpu_count); + memcpy(data->def_cpu_data.cpuset, &cpuset, + data->def_cpu_data.cpusetsize); + create_cpuset_str(&data->def_cpu_data); + data->curr_cpu_data = &data->def_cpu_data; + } + + /* Order of preference: + * 1. Phase cpuset + * 2. Global cpuset + * 3. Default cpuset + */ + if (cpu_data->cpuset != NULL) + actual_cpu_data = cpu_data; + + if (actual_cpu_data->cpuset == NULL) + actual_cpu_data = &data->def_cpu_data; + + if (!CPU_EQUAL(actual_cpu_data->cpuset, data->curr_cpu_data->cpuset)) + { + log_notice("[%d] setting cpu affinity to CPU(s) %s", data->ind, + actual_cpu_data->cpuset_str); + ret = pthread_setaffinity_np(pthread_self(), + actual_cpu_data->cpusetsize, + actual_cpu_data->cpuset); + if (ret < 0) { + errno = ret; + perror("pthread_setaffinity_np"); + exit(EXIT_FAILURE); + } + data->curr_cpu_data = actual_cpu_data; + } +} + void *thread_body(void *arg) { thread_data_t *data = (thread_data_t*) arg; @@ -475,20 +578,6 @@ void *thread_body(void *arg) /* Get the 1st phase's data */ pdata = &data->phases[0]; - /* Set thread affinity */ - if (data->cpuset != NULL) - { - log_notice("[%d] setting cpu affinity to CPU(s) %s", data->ind, - data->cpuset_str); - ret = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), - data->cpuset); - if (ret < 0) { - errno = ret; - perror("pthread_setaffinity_np"); - exit(EXIT_FAILURE); - } - } - /* Set scheduling policy and print pretty info on stdout */ log_notice("[%d] Using %s policy with priority %d", data->ind, data->sched_policy_descr, data->sched_prio); switch (data->sched_policy) @@ -636,6 +725,8 @@ void *thread_body(void *arg) while (continue_running && (i != data->loop)) { struct timespec t_diff, t_rel_start; + set_thread_affinity(data, &pdata->cpu_data); + if (opts.ftrace) log_ftrace(ft_data.marker_fd, "[%d] begins loop %d phase %d step %d", data->ind, i, j, loop); log_debug("[%d] begins loop %d phase %d step %d", data->ind, i, j, loop);; diff --git a/src/rt-app_parse_config.c b/src/rt-app_parse_config.c index 83794f35fe97..63f69b0c3a15 100644 --- a/src/rt-app_parse_config.c +++ b/src/rt-app_parse_config.c @@ -631,15 +631,44 @@ parse_thread_phase_data(struct json_object *obj, } } +static void parse_cpuset_data(struct json_object *obj, cpu_data_t *data) +{ + struct json_object *cpuset_obj, *cpu; + + /* cpuset */ + cpuset_obj = get_in_object(obj, "cpus", TRUE); + if (cpuset_obj) { + struct array_list *cpuset; + unsigned int i; + unsigned int cpu_idx; + + assure_type_is(cpuset_obj, obj, "cpus", json_type_array); + data->cpuset_str = strdup(json_object_to_json_string(cpuset_obj)); + data->cpusetsize = sizeof(cpu_set_t); + data->cpuset = malloc(data->cpusetsize); + cpuset = json_object_get_array(cpuset_obj); + CPU_ZERO(data->cpuset); + for (i = 0; i < json_object_array_length(cpuset_obj); i++) { + cpu = json_object_array_get_idx(cpuset_obj, i); + cpu_idx = json_object_get_int(cpu); + CPU_SET(cpu_idx, data->cpuset); + } + } else { + data->cpuset_str = strdup("-"); + data->cpuset = NULL; + data->cpusetsize = 0; + } + log_info(PIN "key: cpus %s", data->cpuset_str); +} + static void parse_thread_data(char *name, struct json_object *obj, int index, thread_data_t *data, rtapp_options_t *opts) { char *policy; char def_policy[RTAPP_POLICY_DESCR_LENGTH]; - struct array_list *cpuset; - struct json_object *cpuset_obj, *phases_obj, *cpu, *resources, *locks; - int i, cpu_idx, prior_def; + struct json_object *phases_obj, *resources, *locks; + int prior_def; log_info(PFX "Parsing thread %s [%d]", name, index); @@ -648,8 +677,11 @@ parse_thread_data(char *name, struct json_object *obj, int index, data->ind = index; data->name = strdup(name); data->lock_pages = opts->lock_pages; - data->cpuset = NULL; - data->cpuset_str = NULL; + data->cpu_data.cpuset = NULL; + data->cpu_data.cpuset_str = NULL; + data->curr_cpu_data = NULL; + data->def_cpu_data.cpuset = NULL; + data->def_cpu_data.cpuset_str = NULL; /* policy */ policy_to_string(opts->policy, def_policy); @@ -683,23 +715,7 @@ parse_thread_data(char *name, struct json_object *obj, int index, data->deadline = get_int_value_from(obj, "deadline", TRUE, data->period); /* cpuset */ - cpuset_obj = get_in_object(obj, "cpus", TRUE); - if (cpuset_obj) { - assure_type_is(cpuset_obj, obj, "cpus", json_type_array); - data->cpuset_str = strdup(json_object_to_json_string(cpuset_obj)); - data->cpuset = malloc(sizeof(cpu_set_t)); - cpuset = json_object_get_array(cpuset_obj); - CPU_ZERO(data->cpuset); - for (i = 0; i < json_object_array_length(cpuset_obj); i++) { - cpu = json_object_array_get_idx(cpuset_obj, i); - cpu_idx = json_object_get_int(cpu); - CPU_SET(cpu_idx, data->cpuset); - } - } else { - data->cpuset_str = strdup("-"); - data->cpuset = NULL; - } - log_info(PIN "key: cpus %s", data->cpuset_str); + parse_cpuset_data(obj, &data->cpu_data); /* initial delay */ data->delay = get_int_value_from(obj, "delay", TRUE, 0); @@ -726,6 +742,7 @@ parse_thread_data(char *name, struct json_object *obj, int index, foreach(phases_obj, entry, key, val, idx) { log_info(PIN "Parsing phase %s", key); parse_thread_phase_data(val, &data->phases[idx], opts, (long)data); + parse_cpuset_data(val, &data->phases[idx].cpu_data); } /* Get loop number */ @@ -735,6 +752,7 @@ parse_thread_data(char *name, struct json_object *obj, int index, data->nphases = 1; data->phases = malloc(sizeof(phase_data_t) * data->nphases); parse_thread_phase_data(obj, &data->phases[0], opts, (long)data); + parse_cpuset_data(obj, &data->phases[0].cpu_data); /* Get loop number */ data->loop = 1; } diff --git a/src/rt-app_types.h b/src/rt-app_types.h index 5b8345fcf6aa..918a2ccc616c 100644 --- a/src/rt-app_types.h +++ b/src/rt-app_types.h @@ -123,10 +123,17 @@ typedef struct _event_data_t { int count; } event_data_t; +typedef struct _cpu_data_t { + cpu_set_t *cpuset; + char *cpuset_str; + size_t cpusetsize; +} cpu_data_t; + typedef struct _phase_data_t { int loop; event_data_t *events; int nbevents; + cpu_data_t cpu_data; } phase_data_t; typedef struct _thread_data_t { @@ -135,8 +142,9 @@ typedef struct _thread_data_t { int lock_pages; int duration; rtapp_resource_t **resources; - cpu_set_t *cpuset; - char *cpuset_str; + cpu_data_t cpu_data; /* cpu set information */ + cpu_data_t *curr_cpu_data; /* Current cpu set being used */ + cpu_data_t def_cpu_data; /* Default cpu set for task */ unsigned long runtime, deadline, period; -- 2.10.0.297.gf6727b0

7 years, 2 months

[PATCH] Remove unsued cpuset in parse_thread_data()

by Dietmar Eggemann

Signed-off-by: Dietmar Eggemann <dietmar.eggemann(a)arm.com> --- src/rt-app_parse_config.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/rt-app_parse_config.c b/src/rt-app_parse_config.c index 83794f35fe97..e5ef87f6ee3e 100644 --- a/src/rt-app_parse_config.c +++ b/src/rt-app_parse_config.c @@ -637,7 +637,6 @@ parse_thread_data(char *name, struct json_object *obj, int index, { char *policy; char def_policy[RTAPP_POLICY_DESCR_LENGTH]; - struct array_list *cpuset; struct json_object *cpuset_obj, *phases_obj, *cpu, *resources, *locks; int i, cpu_idx, prior_def; @@ -688,7 +687,6 @@ parse_thread_data(char *name, struct json_object *obj, int index, assure_type_is(cpuset_obj, obj, "cpus", json_type_array); data->cpuset_str = strdup(json_object_to_json_string(cpuset_obj)); data->cpuset = malloc(sizeof(cpu_set_t)); - cpuset = json_object_get_array(cpuset_obj); CPU_ZERO(data->cpuset); for (i = 0; i < json_object_array_length(cpuset_obj); i++) { cpu = json_object_array_get_idx(cpuset_obj, i); -- 2.11.0

7 years, 3 months

[PATCH v3 00/17] Align Linaro's and ARM's rt-app trees

by Juri Lelli

Hi all, this is an attempt to align and finally merge Linaro's and ARM's versions of rt-app. v3 should address Vincent's comments on v2 (by also adding a couple of patches, the log header description one and the relative/absolute timers one). Please comment and let me know if this new version of the set is OK for merging. Thanks a lot, - Juri [1] https://github.com/scheduler-tools/rt-app/commits/master Juri Lelli (17): doc: clarify example for config step rt-app: fix compile warnings rt-app: add a t_zero to which every tasks has to refer rt-app: convert log header to fixed width spaces rt-app: add wake-up latency to the log metrics rt-app: add slack to log metrics rt-app: fix batch tasks rt-app: add 'configured period' to log metrics rt-app: write logs only if continue_running is set rt-app: refactor log data to reduce the number of parameters of run() rt-app: move wu_lat to the end of the log rt-app: make c_prd c_period and enlarge it rt-app: add configured duration (c_duration) to log metrics doc: add log header fields descriptions rt-app: let caller manage tracing start/stop rt-app: add delay thread property rt-app: implement relative/absolute timers doc/examples/cpufreq_governor_efficiency/dvfs.sh | 2 +- doc/tutorial.txt | 128 +++++++++++++++++++-- libdl/dl_syscalls.h | 4 +- src/rt-app.c | 137 ++++++++++++++++------- src/rt-app_args.h | 3 - src/rt-app_parse_config.c | 11 ++ src/rt-app_parse_config.h | 2 + src/rt-app_types.h | 16 +++ src/rt-app_utils.c | 27 ++++- src/rt-app_utils.h | 6 + 10 files changed, 278 insertions(+), 58 deletions(-) -- 2.10.0

7 years, 5 months

Re: [Sched-tools] [PATCH v3 06/17] rt-app: add slack to log metrics

by Juri Lelli

On 24/11/16 12:39, Vincent Guittot wrote: > On 24 November 2016 at 12:36, Juri Lelli <juri.lelli(a)arm.com> wrote: > > On 24/11/16 12:26, Vincent Guittot wrote: > >> Le Thursday 24 Nov 2016 à 11:01:50 (+0000), Juri Lelli a écrit : > >> > On 24/11/16 11:54, Vincent Guittot wrote: > >> > > On 24 November 2016 at 11:32, Juri Lelli <juri.lelli(a)arm.com> wrote: > >> > > >> > [...] > >> > > >> > > > @@ -311,6 +311,8 @@ static int run_event(event_data_t *event, int dry_run, > >> > > > > >> > > > rdata->res.timer.t_next = timespec_add(&rdata->res.timer.t_next, &t_period); > >> > > > clock_gettime(CLOCK_MONOTONIC, &t_now); > >> > > > + t_slack = timespec_sub(&rdata->res.timer.t_next, &t_now); > >> > > > + *slack += timespec_to_usec_long(&t_slack); > >> > > > >> > > As said in previous patch, i think that you have mixed wake up latency and slack > >> > > According to the description in patch 14 : > >> > > slack: for periodic phases (phases that ends with a timer), time > >> > > between the end of last event and the end of the phase, e.g > >> > > > >> > > you should have *slack = timespec_to_usec_long(&t_slack); > >> > > > >> > > >> > I agree on the wu_lat (will fix the corresponding patch). > >> > > >> > On the slack we probably didn't finish the discussion started on v2. I'm > >> > summing up beacuse we can have multiple timer events in the same phase, > >> > and though that sum up intermediate slacks is a sensible thing to do. > >> > What you think? (if we go this direction I'll of course update the > >> > description in patch 14). > >> > >> So my original understanding of slack was that you want to get the > >> "margin" or " real idle" time in a phase which means that we are > >> interested in summing the slack values of the different timers of a > >> phase (1st example below) Then, we started to discuss the use of slack > >> as a margin to be compared with the deadline of a deadline task and in > >> this case only the slack of the last timer is relevant (2nd example). > >> > >> If I take an example similar to the one in patch 14 > >> > >> your current proposal is doing this > >> taskA ...|-- run5 --|- timer7 -|-- run5--|..timer13.|-- run5 --|- timer7 -|-- run6 --|.timer13..| > >> <--------------- period 20 --------------> <--------------- period 20 ---------------> > >> <-slack2-> <+slack5-> <-slack2-> <+slack4-> > >> > >> so slack will be +7 and then +6 > >> > >> And from a deadline point of view only the last slack of the period is > >> interesting > >> taskA ...|-- run5 --|- timer7 -|-- run5--|..timer13.|-- run5 --|- timer7 -|-- run6 --|.timer13..| > >> <--------------- period 20 --------------> <--------------- period 20 ---------------> > >> <-slack5-> <-slack4-> > > > > Humm, to be honest, both make sense to me and might be useful. :) > > > > Patrick is proposing that we add another property to timer events > > > > "slack" : "[cumulative|last]" > > > > What you think? > > yes, that's probably a good solution. So this will be a new parameters > of the global object ? No, I was actually thinking we put it in timer events. "timer0" : { "ref" : "unique", "period" : 20000, "slack" : "cumulative" }, the default being "last"?

7 years, 5 months

[PATCH v2 00/14] Align Linaro's and ARM's rt-app trees

by Juri Lelli

Hi all, this is an attempt to align and finally merge Linaro's and ARM's versions of rt-app. v2 should address Vincent's comments on v1, plus I added a patch about tracing (13/14) that I thought need fixing while I was doing more debugging. Please let me know if this new version of the set is OK for merging. Thanks a lot, - Juri [1] https://github.com/scheduler-tools/rt-app/commits/master Juri Lelli (14): doc: clarify example for config step rt-app: fix compile warnings rt-app: add a t_zero to which every tasks has to refer rt-app: add wake-up latency to the log metrics rt-app: add slack to log metrics rt-app: fix batch tasks rt-app: add 'configured period' to log metrics rt-app: write logs only if continue_running is set rt-app: refactor log data to reduce the number of parameters of run() rt-app: move wu_lat to the end of the log rt-app: make c_prd c_period and enlarge it rt-app: add configured run (c_run) to log metrics rt-app: let caller manage tracing start/stop rt-app: add delay thread property doc/tutorial.txt | 28 +++++++++++ libdl/dl_syscalls.h | 4 +- src/rt-app.c | 121 +++++++++++++++++++++++++++++++++++----------- src/rt-app_args.h | 3 -- src/rt-app_parse_config.c | 5 ++ src/rt-app_parse_config.h | 2 + src/rt-app_types.h | 15 ++++++ src/rt-app_utils.c | 27 +++++++++-- src/rt-app_utils.h | 6 +++ 9 files changed, 175 insertions(+), 36 deletions(-) -- 2.10.0

7 years, 5 months

[PATCH 00/13] Align Linaro's and ARM's rt-app trees

by Juri Lelli

Hi all, this is an attempt to align and finally merge Linaro's and ARM's versions of rt-app (so that we make the whole story more clean and sound and possibly facilitate adoption by even more people). Apologies for not doing this before and not being responsive to Vincent and Pi-Cheng previous attemps; turns out that I never had really the time to seriously looking at this until now. Anyway, I've already pushed Linaro's current tree on scheduler-tools/rt-app master[1] (and added Vincent as co-maintainer); this series is based on top of that. These patches represent the deltas between what we currently use (for EAS evaluation and LISA tooling) and Linaro's version. Please have a look and comment. I slightly tested them and couldn't find any problems yet; please, do the same. Thanks a lot, - Juri [1] https://github.com/scheduler-tools/rt-app/commits/master Juri Lelli (13): doc: clarify example for config step rt-app: fix compile warnings rt-app: add a t_zero to which every tasks has to refer rt-app: add wake-up latency to the log metrics rt-app: add slack to log metrics rt-app: add 'delay' phase rt-app: fix batch tasks rt-app: add 'configured period' to log metrics rt-app: write logs only if continue_running is set rt-app: refactor log data to reduce the number of parameters of run() rt-app: move wu_lat to the end of the log rt-app: make c_prd c_period and enlarge it rt-app: add configured run (c_run) to log metrics doc/tutorial.txt | 25 ++++++++++ libdl/dl_syscalls.h | 4 +- src/rt-app.c | 113 ++++++++++++++++++++++++++++++++++++---------- src/rt-app_args.h | 3 -- src/rt-app_parse_config.c | 6 ++- src/rt-app_parse_config.h | 2 + src/rt-app_types.h | 14 ++++++ src/rt-app_utils.c | 23 ++++++++-- src/rt-app_utils.h | 6 +++ 9 files changed, 162 insertions(+), 34 deletions(-) -- 2.10.0

7 years, 5 months

[PATCH RESEND 0/5] rt-app cpufreq/dvfs test cleanups and new features

by Steve Muckle

During my time working with the rt-app cpufreq efficiency test I came across a few rough edges. Patches 1-4 address those. Patch 5 essentially rewrites the test.sh script. Prior to this patch test.sh takes a single governor and workload specification (duty cycle). It runs the workload with this governor as well as the perf and power governors then calculates efficiency. If we want to profile multiple governors, using this script would result in running the workload under the perf and power governors multiple times. You could run dvfs.sh script directly in which case the efficiency must be manually calculated. Patch 5 adds support to test.sh to accept a test specification file with the -f parameter. A test specification file specifies the CPU to run the tests on, the governors to test (excluding the perf and power governors), and the workloads to test. It looks like this: 1 ondemand interactive schedutil 1 100 100 10 1000 10 1 10 1000 The workloads are specified as: <busy time @fmax in ms> <period length in ms> <# of loops> The results are output in a text-formatted table suitable for email. CPU frequency residency is also tracked as part of patch 5. At the end of the testing the residencies for each test for a given governor are printed in a table. This depends on cpufreq stats being enabled on the platform. The test.sh script continues to accept arguments as it did previously, i.e. it will accept a single governor and workload on the command line. Steve Muckle (5): rt-app: fix cpufreq test loops rt-app: change default sched class for dvfs test to SCHED_OTHER rt-app: tidy up cpufreq efficiency README rt-app: save and restore governor in dvfs.sh cpufreq efficency test rt-app: rework cpufreq efficiency script doc/examples/cpufreq_governor_efficiency/README | 85 ++++--- doc/examples/cpufreq_governor_efficiency/dvfs.json | 4 +- doc/examples/cpufreq_governor_efficiency/dvfs.sh | 13 +- doc/examples/cpufreq_governor_efficiency/test.sh | 246 ++++++++++++++------- 4 files changed, 238 insertions(+), 110 deletions(-) -- 2.7.3

7 years, 5 months

[PATCH v2 0/2] rt-app: add a runtime event

by Javi Merino

Sometimes we need a create load that can run in any CPU of the system for a given period of time, regardless of their compute capacity. Add a runtime event to be able to generate such a load. Changes since v1: - Change runtime granularity to 10usec - Reorder run and runtime in run_event() and in the tutorial.txt Javi Merino (2): rt-parse: avoid repetition in obj_is_event() rt-app: add a runtime event doc/tutorial.txt | 5 +++++ src/rt-app.c | 20 +++++++++++++++++ src/rt-app_parse_config.c | 57 ++++++++++++++++++++++++----------------------- src/rt-app_types.h | 1 + 4 files changed, 55 insertions(+), 28 deletions(-) -- 1.9.1

7 years, 8 months

← Newer
1
2
3
4
5
6
7
8
9
10
Older →

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

Sched-tools