Relevante manpages:

• GETRLIMIT(2): http://man7.org/linux/man-pages/man2/getrlimit.2.html
• GETRUSAGE(2): http://man7.org/linux/man-pages/man2/getrusage.2.html
• CLOCK(3): http://man7.org/linux/man-pages/man3/clock.3.html

Mit folgendem Beispiel wird die Funktionsweise von getrlimit() und setrlimit() gezeigt.

#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include <sys/resource.h>
 
 
/*
 * Zur Info: "struct rusage" hat folgende Definition:
 *
	struct rusage
	{
		struct timeval ru_utime; // user CPU time used
		struct timeval ru_stime; // system CPU time used
		long   ru_maxrss;        // maximum resident set size
		long   ru_ixrss;         // integral shared memory size
		long   ru_idrss;         // integral unshared data size
		long   ru_isrss;         // integral unshared stack size
		long   ru_minflt;        // page reclaims (soft page faults)
		long   ru_majflt;        // page faults (hard page faults)
		long   ru_nswap;         // swaps
		long   ru_inblock;       // block input operations
		long   ru_oublock;       // block output operations
		long   ru_msgsnd;        // IPC messages sent
		long   ru_msgrcv;        // IPC messages received
		long   ru_nsignals;      // signals received
		long   ru_nvcsw;         // voluntary context switches
		long   ru_nivcsw;        // involuntary context switches
	};
 */
 
/*
 * Zur Info: "struct timeval" hat folgende Definition:
 *
	struct timeval
	{
		long int tv_sec;	// Number of seconds since the epoch. It is equivalent to a normal time_t value.
		long int tv_usec;	// Fractional second value, represented as the number of microseconds.
	};
 */
 
/*
 * Zur Info: "struct rlimit" hat folgende Definition:
 *
	struct rlimit
	{
		rlim_t rlim_cur;	// Soft limit.
		rlim_t rlim_max;	// Hard limit (ceiling for rlim_cur).
	};
 */
 
/*
 * Zur Info: "rlim_t" hat folgende Definition:
 *
 * The rlim_t type is an arithmetic data type to which you can cast objects of
 * type int, size_t, and off_t without loss of information.
 */
 
 
// Anzahl an Arbeitzyklen:
#define i_MAX_AZ 3000	// Aussere Schleife
#define j_MAX_AZ 3000	// Innere Schleife
 
// CPU-Limits in Sekunden
#define CPU_LIMIT_SOFT 5
#define CPU_LIMIT_HARD 9
 
 
int main (void)
{
	int rc_main = 0;
	int rc_getrusage = 0;
	int rc_getrlimit = 0;
	int rc_setrlimit = 0;
	long int i, j, s;
 
	struct rusage cpu_usage_self;
	struct rusage cpu_usage_children;
	struct rusage cpu_usage_thread;
 
	struct rlimit cpu_timelimit_rlimit;
 
	time_t aktSekunden1, aktSekunden2;
 
 
 
	printf("\nTest von CPU-Time Funktionen\n\n");
 
	printf("\n======================================================================\n");
 
	printf("\nInitialisierung:\n\n");
 
	memset(&cpu_usage_self,       0, sizeof(cpu_usage_self));
	memset(&cpu_usage_children,   0, sizeof(cpu_usage_children));
	memset(&cpu_usage_thread,     0, sizeof(cpu_usage_thread));
	memset(&cpu_timelimit_rlimit, 0, sizeof(cpu_timelimit_rlimit));
 
	printf("\n======================================================================\n");
	// Timestamp am Anfang merken um spaeter die Laufzeit (nicht die CPU-Zeit!)
	// des Programms zu berechnen.
 
	printf("aktSekunden1 = time(NULL);\n");
	aktSekunden1 = time(NULL);
	printf("time(): RC = %d\n", (int) aktSekunden1);
 
	printf("\n======================================================================\n");
	// Aktuelle Soft- und Hard-CPU-Limits lesen.
 
	printf("\nTest der Funktion: %s\n", "getrlimit()");
	printf("Syntax: %s\n", "int getrlimit(int resource, struct rlimit *rlim);");
 
	printf("resource = [%s]\n", "RLIMIT_CPU");
	rc_getrlimit = getrlimit(RLIMIT_CPU, &cpu_timelimit_rlimit);
	printf("getrlimit(): RC = %d\n", rc_getrlimit);
 
	printf("\nErgebnisse:\n\n");
 
	printf("Response von getrlimit() - RLIMIT_CPU:\n");
	printf("\tCPU SoftLimit: rlim_cur  = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_cur);
	printf("\tCPU HardLimit: rlim_max  = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_max);
 
	printf("\n======================================================================\n");
	// Neue Soft- und Hard-CPU-Limits setzen.
 
	printf("\nTest der Funktion: %s\n", "setrlimit()");
	printf("Syntax: %s\n", "int setrlimit(int resource, const struct rlimit *rlim);");
 
	cpu_timelimit_rlimit.rlim_cur = CPU_LIMIT_SOFT;
	cpu_timelimit_rlimit.rlim_max = CPU_LIMIT_HARD;
 
	printf("CPU-Limits werden auf folgende Werte gesetzt:\n");
	printf("\tCPU SoftLimit: rlim_cur  = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_cur);
	printf("\tCPU HardLimit: rlim_max  = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_max);
 
	printf("resource = [%s]\n", "RLIMIT_CPU");
	rc_setrlimit = setrlimit(RLIMIT_CPU, &cpu_timelimit_rlimit);
	printf("setrlimit(): RC = %d\n", rc_setrlimit);
 
	printf("\n======================================================================\n");
	// Aktuelle Soft- und Hard-CPU-Limits nochmals lesen um zu pruefen, ob
	// die oben gesetzte Werte tatsaechlich uebernommen wurden.
 
	printf("\nTest der Funktion: %s\n", "getrlimit()");
	printf("Syntax: %s\n", "int getrlimit(int resource, struct rlimit *rlim);");
 
	printf("resource = [%s]\n", "RLIMIT_CPU");
	rc_getrlimit = getrlimit(RLIMIT_CPU, &cpu_timelimit_rlimit);
	printf("getrlimit(): RC = %d\n", rc_getrlimit);
 
	printf("\nErgebnisse:\n\n");
 
	printf("Response von getrlimit() - RLIMIT_CPU:\n");
	printf("\tCPU SoftLimit: rlim_cur  = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_cur);
	printf("\tCPU HardLimit: rlim_max  = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_max);
 
	printf("\n======================================================================\n");
	// Etwas Last erzeugen und anschliessend die verbrauchte CPU-Zeit auslesen.
	//
	// Hier kann es, wenn das CPU-Limit ueberschritten wird, zum Abbruch kommen.
 
	printf("\nCPU-Last erzeugen - durch Arbeitzyklen:\n\n");
 
	printf("Aussere Schleife = %ld Zyklen\n", (long int) i_MAX_AZ);
	printf("Innere Schleife  = %ld Zyklen\n", (long int) j_MAX_AZ);
	printf("Insgesamt = %ld Schleifenzyklen...\n", s = i_MAX_AZ * j_MAX_AZ);
	for (i = 0; i < i_MAX_AZ; i++) for (j = 0; j < j_MAX_AZ; j++) printf("%ld\r", s = i * j);
	printf("\n");
 
 
 
	printf("\nTest der Funktion: %s\n", "getrusage()");
	printf("Syntax: %s\n", "int getrusage(int who, struct rusage *usage);");
 
	printf("who = [%s]\n", "RUSAGE_SELF");
	rc_getrusage = getrusage(RUSAGE_SELF, &cpu_usage_self);
	printf("getrusage(): RC = %d\n", rc_getrusage);
 
	printf("who = [%s]\n", "RUSAGE_CHILDREN");
	rc_getrusage = getrusage(RUSAGE_CHILDREN, &cpu_usage_children);
	printf("getrusage(): RC = %d\n", rc_getrusage);
 
//	printf("who = [%s]\n", "RUSAGE_THREAD");
//	rc_getrusage = getrusage(RUSAGE_THREAD, &cpu_usage_thread);
//	printf("getrusage(): RC = %d\n", rc_getrusage);
 
 
 
	printf("\nErgebnisse:\n\n");
 
	printf("Response von getrusage() - RUSAGE_SELF:\n");
	printf("\tCPU utime: tv_sec  = %ld\n", cpu_usage_self.ru_utime.tv_sec);
	printf("\tCPU utime: tv_usec = %ld\n", cpu_usage_self.ru_utime.tv_usec);
	printf("\tCPU stime: tv_sec  = %ld\n", cpu_usage_self.ru_stime.tv_sec);
	printf("\tCPU stime: tv_usec = %ld\n", cpu_usage_self.ru_stime.tv_usec);
 
	printf("Response von getrusage() - RUSAGE_CHILDREN:\n");
	printf("\tCPU utime: tv_sec  = %ld\n", cpu_usage_children.ru_utime.tv_sec);
	printf("\tCPU utime: tv_usec = %ld\n", cpu_usage_children.ru_utime.tv_usec);
	printf("\tCPU stime: tv_sec  = %ld\n", cpu_usage_children.ru_stime.tv_sec);
	printf("\tCPU stime: tv_usec = %ld\n", cpu_usage_children.ru_stime.tv_usec);
 
//	printf("Response von getrusage() - RUSAGE_THREAD:\n");
//	printf("\tCPU utime: tv_sec  = %ld\n", cpu_usage_thread.ru_utime.tv_sec);
//	printf("\tCPU utime: tv_usec = %ld\n", cpu_usage_thread.ru_utime.tv_usec);
//	printf("\tCPU stime: tv_sec  = %ld\n", cpu_usage_thread.ru_stime.tv_sec);
//	printf("\tCPU stime: tv_usec = %ld\n", cpu_usage_thread.ru_stime.tv_usec);
 
	printf("\n======================================================================\n");
	// Aktuelle Soft- und Hard-CPU-Limits nochmals lesen um zu pruefen, ob
	// der CPU-Verbrauch diese beeinfluesst hat.
 
	printf("\nTest der Funktion: %s\n", "getrlimit()");
	printf("Syntax: %s\n", "int getrlimit(int resource, struct rlimit *rlim);");
 
	printf("resource = [%s]\n", "RLIMIT_CPU");
	rc_getrlimit = getrlimit(RLIMIT_CPU, &cpu_timelimit_rlimit);
	printf("getrlimit(): RC = %d\n", rc_getrlimit);
 
	printf("\nErgebnisse:\n\n");
 
	printf("Response von getrlimit() - RLIMIT_CPU:\n");
	printf("\tCPU SoftLimit: rlim_cur  = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_cur);
	printf("\tCPU HardLimit: rlim_max  = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_max);
 
	printf("\n======================================================================\n");
	// Timestamp am Ende merken.
 
	printf("aktSekunden2 = time(NULL);\n");
	aktSekunden2 = time(NULL);
	printf("time(): RC = %d\n", (int) aktSekunden2);
 
	if ((aktSekunden1 != -1) && (aktSekunden2 != -1)) printf("\nLaufzeit = %ld Sekunden\n", (long) (aktSekunden2 - aktSekunden1));
	else printf("\nWARNING: Laufzeit kann nicht berechnet werden\n");
 
	printf("\n======================================================================\n");
 
	return rc_main;
} // main()

Stand: 11.10.2013 — : Jürgen Kreick

EOF