Contributors: 2
Author Tokens Token Proportion Commits Commit Proportion
Srinivas Pandruvada 773 99.10% 3 75.00%
Yuli Wang 7 0.90% 1 25.00%
Total 780 4 


// SPDX-License-Identifier: GPL-2.0

#define _GNU_SOURCE

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>

#define WORKLOAD_NOTIFICATION_DELAY_ATTRIBUTE "/sys/bus/pci/devices/0000:00:04.0/workload_hint/notification_delay_ms"
#define WORKLOAD_ENABLE_ATTRIBUTE "/sys/bus/pci/devices/0000:00:04.0/workload_hint/workload_hint_enable"
#define WORKLOAD_SLOW_ENABLE_ATTRIBUTE "/sys/bus/pci/devices/0000:00:04.0/workload_hint/workload_slow_hint_enable"
#define WORKLOAD_TYPE_INDEX_ATTRIBUTE  "/sys/bus/pci/devices/0000:00:04.0/workload_hint/workload_type_index"

static const char * const workload_types[] = {
	"idle",
	"battery_life",
	"sustained",
	"bursty",
	NULL
};

static int wlt_slow;
static char *wlt_enable_attr;

#define WORKLOAD_TYPE_MAX_INDEX	3

void workload_hint_exit(int signum)
{
	int fd;

	/* Disable feature via sysfs knob */

	fd = open(wlt_enable_attr, O_RDWR);
	if (fd < 0) {
		perror("Unable to open workload type feature enable file");
		exit(1);
	}

	if (write(fd, "0\n", 2) < 0) {
		perror("Can't disable workload hints");
		exit(1);
	}

	printf("Disabled workload type prediction\n");

	close(fd);
}

static void update_delay(char *delay_str)
{
	int fd;

	printf("Setting notification delay in ms to %s\n", delay_str);

	fd = open(WORKLOAD_NOTIFICATION_DELAY_ATTRIBUTE, O_RDWR);
	if (fd < 0) {
		perror("Unable to open workload notification delay");
		exit(1);
	}

	if (write(fd, delay_str, strlen(delay_str)) < 0) {
		perror("Can't set delay");
		exit(1);
	}

	close(fd);
}

int main(int argc, char **argv)
{
	struct pollfd ufd;
	char index_str[4];
	int fd, ret, index;
	char delay_str[64];
	int delay = 0;

	printf("Usage: workload_hint_test [notification delay in milli seconds][slow]\n");

	if (argc > 1) {
		int i;

		for (i = 1; i < argc; ++i) {
			if (!strcmp(argv[i], "slow")) {
				wlt_slow = 1;
				continue;
			}

			ret = sscanf(argv[1], "%d", &delay);
			if (ret < 0) {
				printf("Invalid delay\n");
				exit(1);
			}

			sprintf(delay_str, "%s\n", argv[1]);
			update_delay(delay_str);
		}
	}

	if (signal(SIGINT, workload_hint_exit) == SIG_IGN)
		signal(SIGINT, SIG_IGN);
	if (signal(SIGHUP, workload_hint_exit) == SIG_IGN)
		signal(SIGHUP, SIG_IGN);
	if (signal(SIGTERM, workload_hint_exit) == SIG_IGN)
		signal(SIGTERM, SIG_IGN);

	if (wlt_slow)
		wlt_enable_attr = WORKLOAD_SLOW_ENABLE_ATTRIBUTE;
	else
		wlt_enable_attr = WORKLOAD_ENABLE_ATTRIBUTE;

	/* Enable feature via sysfs knob */
	fd = open(wlt_enable_attr, O_RDWR);
	if (fd < 0) {
		perror("Unable to open workload type feature enable file");
		exit(1);
	}

	if (write(fd, "1\n", 2) < 0) {
		perror("Can't enable workload hints");
		exit(1);
	}

	close(fd);

	printf("Enabled workload type prediction\n");

	while (1) {
		fd = open(WORKLOAD_TYPE_INDEX_ATTRIBUTE, O_RDONLY);
		if (fd < 0) {
			perror("Unable to open workload type file");
			exit(1);
		}

		if ((lseek(fd, 0L, SEEK_SET)) < 0) {
			fprintf(stderr, "Failed to set pointer to beginning\n");
			exit(1);
		}

		if (read(fd, index_str, sizeof(index_str)) < 0) {
			fprintf(stderr, "Failed to read from:%s\n",
			WORKLOAD_TYPE_INDEX_ATTRIBUTE);
			exit(1);
		}

		ufd.fd = fd;
		ufd.events = POLLPRI;

		ret = poll(&ufd, 1, -1);
		if (ret < 0) {
			perror("poll error");
			exit(1);
		} else if (ret == 0) {
			printf("Poll Timeout\n");
		} else {
			if ((lseek(fd, 0L, SEEK_SET)) < 0) {
				fprintf(stderr, "Failed to set pointer to beginning\n");
				exit(1);
			}

			if (read(fd, index_str, sizeof(index_str)) < 0)
				exit(0);

			ret = sscanf(index_str, "%d", &index);
			if (ret < 0)
				break;

			if (wlt_slow) {
				if (index & 0x10)
					printf("workload type slow:%s\n", "power");
				else
					printf("workload type slow:%s\n", "performance");
			}

			index &= 0x0f;
			if (index > WORKLOAD_TYPE_MAX_INDEX)
				printf("Invalid workload type index\n");
			else
				printf("workload type:%s\n", workload_types[index]);
		}

		close(fd);
	}
}