Example program for PRIO_RGRP

From: Tejun Heo
Date: Fri Mar 11 2016 - 11:05:33 EST


Hello,

The attached test-rgrp-burn.c is an example program making use of the
new PRIO_RGRP. The test program creates rgroup the following rgroup
hierarchy

sgroup - main thread
+ [rgroup-0] burner-0
+ [rgroup-1] + [rgroup-2] burner-1
+ [rgroup-3] burner-2

and takes upto 4 arguments respectively specifying the nice level for
each rgroup. Each burner thread executes CPU burning loops and
periodically prints out how many loops it has completed.

* "./test-rgrp-burn"

If the program is run without any argument, on a kernel which doesn't
support rgroup, or from a cgroup where cpu controller is not
available, the three burner threads would run at about equivalent
speeds.

* "./test-rgrp-burn 0" from a cgroup w/ cpu controller

cpu controller is enabled across the top-level, so rgroup-0 and
rgroup-1 would compete on equal footing, so burner-0 runs twice as
fast as burner-1 or burner-2.

* "./test-rgrp-burn 0 3 -1 2" from a cgroup w/ cpu controller

cpu controller is enabled at both levels. Nice level difference of 3
is about twice difference in weight, so the ratio would roughly be

burner-0 : burner-1 : burner-2 ~= 3 : 2 : 1

Thanks.

--
tejun
/*
* test-rgrp-burn - rgrp test program
*
* Creates the following rgrp hierarchy of three CPU cycle burner
* threads.
*
* sgrp - main thread
* + [rgrp-0] burner thread
* + [rgrp-1] + [rgrp-2] nested burner thread
* + [rgrp-3] nested burner thread
*
* Takes upto 4 arguments specifying the nice level of each rgrp.
*/
#define _GNU_SOURCE

#include <sys/types.h>
#include <sys/wait.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <pthread.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/resource.h>

#define CLONE_NEWRGRP 0x00001000 /* New resource group */
#define PRIO_RGRP 3
#define STACK_SIZE (4 * 1024 * 1024)
#define CLONE_THREAD_FLAGS (CLONE_THREAD | CLONE_SIGHAND | CLONE_VM | \
CLONE_FS | CLONE_FILES)

static int nice_val[] = { [0 ... 3] = INT_MIN };

static pthread_mutex_t lprintf_mutex;

#define lprintf(fmt, args...) do { \
pthread_mutex_lock(&lprintf_mutex); \
printf(fmt, ##args); \
pthread_mutex_unlock(&lprintf_mutex); \
} while (0)

static int gettid(void)
{
return syscall(SYS_gettid);
}

static int burner_fn(void *arg)
{
unsigned long a = 37, cnt = 0;

sleep(1);

lprintf("burner : %d started\n", gettid());

while (1) {
*(volatile unsigned long *)&a = a * 37 / 13 + 53;
*(volatile unsigned long *)&a = a * 37 / 13 + 53;
*(volatile unsigned long *)&a = a * 37 / 13 + 53;
*(volatile unsigned long *)&a = a * 37 / 13 + 53;
*(volatile unsigned long *)&a = a * 37 / 13 + 53;
*(volatile unsigned long *)&a = a * 37 / 13 + 53;
*(volatile unsigned long *)&a = a * 37 / 13 + 53;
*(volatile unsigned long *)&a = a * 37 / 13 + 53;

if (!(++cnt % (1000000 * 100))) {
int prio;

errno = 0;
prio = getpriority(PRIO_RGRP, 0);
lprintf("burner : %d finished %lum loops (rgrp nice=%d errno=%d)\n",
gettid(), cnt / 1000000, prio, errno);
}
}

return 0;
}

static void rgrp_setprio(pid_t pid, int nice)
{
if (nice == INT_MIN)
return;

lprintf("setprio: setting PRIO_RGRP to %d on %d\n", nice, pid);
if (setpriority(PRIO_RGRP, pid, nice))
perror("setpriority");
}

static int child_fn(void *arg)
{
char *stack;
pid_t pid;

stack = malloc(STACK_SIZE) + STACK_SIZE;
pid = clone(burner_fn, stack, CLONE_THREAD_FLAGS | CLONE_NEWRGRP, NULL);
lprintf("child : cloned nested burner %d\n", pid);
rgrp_setprio(pid, nice_val[2]);

stack = malloc(STACK_SIZE) + STACK_SIZE;
pid = clone(burner_fn, stack, CLONE_THREAD_FLAGS | CLONE_NEWRGRP, NULL);
lprintf("child : cloned nested burner %d\n", pid);
rgrp_setprio(pid, nice_val[3]);

sleep(500);
return 0;
}

int main(int argc, char **argv)
{
char *stack;
pid_t pid;
int i;

if (argc > 5)
argc = 5;

for (i = 1; i < argc; i++)
nice_val[i - 1] = atoi(argv[i]);

pthread_mutex_init(&lprintf_mutex, NULL);

stack = malloc(STACK_SIZE) + STACK_SIZE;
pid = clone(burner_fn, stack, CLONE_THREAD_FLAGS | CLONE_NEWRGRP, NULL);
lprintf("main : cloned burner %d\n", pid);
rgrp_setprio(pid, nice_val[0]);

stack = malloc(STACK_SIZE) + STACK_SIZE;
pid = clone(child_fn, stack, CLONE_THREAD_FLAGS | CLONE_NEWRGRP, NULL);
lprintf("main : cloned child %d\n", pid);
rgrp_setprio(pid, nice_val[1]);

sleep(500);
return 0;
}