[apple/xnu.git] / tests / task_vm_info_decompressions.c

#include <stdlib.h>
#include <stdio.h>
#include <mach/task_info.h>
#include <mach/mach.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <sys/kern_memorystatus.h>
#include <sys/sysctl.h>
#include <stdatomic.h>

#include <darwintest.h>
#include <TargetConditionals.h>

#define KB 1024
#define MALLOC_SIZE_PER_THREAD (64 * KB)
#define freezer_path "/usr/local/bin/freeze"

/* BridgeOS could spend more time execv freezer */
#if TARGET_OS_BRIDGE
static int timeout = 600;
#else
static int timeout = 120;
#endif

static _Atomic int thread_malloc_count = 0;
static _Atomic int thread_thawed_count = 0;
static _Atomic int phase = 0;

struct thread_args {
	int    id;
};

static void
freeze_pid(pid_t pid)
{
	char pid_str[6];
	char *args[3];
	pid_t child_pid;
	int status;

	sprintf(pid_str, "%d", pid);
	child_pid = fork();
	if (child_pid == 0) {
		/* Launch freezer */
		args[0] = freezer_path;
		args[1] = pid_str;
		args[2] = NULL;
		execv(freezer_path, args);
		/* execve() does not return on success */
		perror("execve");
		T_FAIL("execve() failed");
	}

	/* Wait for freezer to complete */
	T_LOG("Waiting for freezer %d to complete", child_pid);
	while (0 == waitpid(child_pid, &status, WNOHANG)) {
		if (timeout < 0) {
			kill(child_pid, SIGKILL);
			T_FAIL("Freezer took too long to freeze the test");
		}
		sleep(1);
		timeout--;
	}
	if (WIFEXITED(status) != 1 || WEXITSTATUS(status) != 0) {
		T_FAIL("Freezer error'd out");
	}
}
static void *
worker_thread_function(void *args)
{
	struct thread_args *targs = args;
	int thread_id = targs->id;
	char *array;

	/* Allocate memory */
	array = malloc(MALLOC_SIZE_PER_THREAD);
	T_EXPECT_NOTNULL(array, "thread %d allocated heap memory to be dirtied", thread_id);

	/* Waiting for phase 1 (touch pages) to start */
	while (atomic_load(&phase) != 1) {
		;
	}

	/* Phase 1: touch pages */
	T_LOG("thread %d phase 1: dirtying %d heap pages (%d bytes)", thread_id, MALLOC_SIZE_PER_THREAD / (int)PAGE_SIZE, MALLOC_SIZE_PER_THREAD);
	memset(&array[0], 1, MALLOC_SIZE_PER_THREAD);
	atomic_fetch_add(&thread_malloc_count, 1);

	/* Wait for process to be frozen */
	while (atomic_load(&phase) != 2) {
		;
	}

	/* Phase 2, process thawed, trigger decompressions by re-faulting pages */
	T_LOG("thread %d phase 2: faulting pages back in to trigger decompressions", thread_id);
	memset(&array[0], 1, MALLOC_SIZE_PER_THREAD);

	/* Main thread will retrieve vm statistics once all threads are thawed */
	atomic_fetch_add(&thread_thawed_count, 1);

	free(array);


#if 0 /* Test if the thread's decompressions counter was added to the task decompressions counter when a thread terminates */
	if (thread_id < 2) {
		sleep(10);
	}
#endif

	return NULL;
}

static pthread_t*
create_threads(int nthreads, pthread_t *threads, struct thread_args *targs)
{
	int i;
	int err;
	pthread_attr_t attr;

	err = pthread_attr_init(&attr);
	T_ASSERT_POSIX_ZERO(err, "pthread_attr_init");
	for (i = 0; i < nthreads; i++) {
		targs[i].id = i;
		err = pthread_create(&threads[i], &attr, worker_thread_function, (void*)&targs[i]);
		T_QUIET; T_ASSERT_POSIX_ZERO(err, "pthread_create");
	}

	return threads;
}

static void
join_threads(int nthreads, pthread_t *threads)
{
	int i;
	int err;

	for (i = 0; i < nthreads; i++) {
		err = pthread_join(threads[i], NULL);
		T_QUIET; T_ASSERT_POSIX_ZERO(err, "pthread_join");
	}
}

T_DECL(task_vm_info_decompressions,
    "Test multithreaded per-task decompressions counter")
{
	int     err;
	int     ncpu;
	size_t  ncpu_size = sizeof(ncpu);
	int     npages;
	int     compressor_mode;
	size_t  compressor_mode_size = sizeof(compressor_mode);
	task_vm_info_data_t vm_info;
	mach_msg_type_number_t count;
	pthread_t *threads;
	struct thread_args *targs;

	T_SETUPBEGIN;

	/* Make sure freezer is enabled on target machine */
	err = sysctlbyname("vm.compressor_mode", &compressor_mode, &compressor_mode_size, NULL, 0);
	if (compressor_mode < 8) {
		T_SKIP("This test requires freezer which is not available on the testing platform (vm.compressor_mode is set to %d)", compressor_mode);
	}
#if TARGET_OS_BRIDGE
	T_SKIP("This test requires freezer which is not available on bridgeOS (vm.compressor_mode is set to %d)", compressor_mode);
#endif

	/* Set number of threads to ncpu available on testing device */
	err = sysctlbyname("hw.ncpu", &ncpu, &ncpu_size, NULL, 0);
	T_EXPECT_EQ_INT(0, err, "Detected %d cpus\n", ncpu);

	/* Set total number of pages to be frozen */
	npages = ncpu * MALLOC_SIZE_PER_THREAD / (int)PAGE_SIZE;
	T_LOG("Test will be freezing at least %d heap pages\n", npages);

	/* Change state to freezable */
	err = memorystatus_control(MEMORYSTATUS_CMD_SET_PROCESS_IS_FREEZABLE, getpid(), (uint32_t)1, NULL, 0);
	T_EXPECT_EQ(KERN_SUCCESS, err, "set pid %d to be freezable", getpid());

	/* Call into kernel to retrieve vm_info and make sure we do not have any decompressions before the test */
	count = TASK_VM_INFO_COUNT;
	err = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t)&vm_info, &count);
	T_EXPECT_EQ(count, TASK_VM_INFO_COUNT, "count == TASK_VM_INFO_COUNT: %d", count);
	T_EXPECT_EQ_INT(0, err, "task_info(TASK_VM_INFO) returned 0");
	T_EXPECT_EQ_INT(0, vm_info.decompressions, "Expected 0 decompressions before test starts");

	/* Thread data */
	threads = malloc(sizeof(pthread_t) * (size_t)ncpu);
	targs = malloc(sizeof(struct thread_args) * (size_t)ncpu);

	T_SETUPEND;

	/* Phase 1: create threads to write to malloc memory */
	create_threads(ncpu, threads, targs);
	atomic_fetch_add(&phase, 1);

	/* Wait for all threads to dirty their malloc pages */
	while (atomic_load(&thread_malloc_count) != ncpu) {
		sleep(1);
	}
	T_EXPECT_EQ(ncpu, atomic_load(&thread_malloc_count), "%d threads finished writing to malloc pages\n", ncpu);

	/* Launch freezer to compress the dirty pages */
	T_LOG("Running freezer to compress pages for pid %d", getpid());
	freeze_pid(getpid());

	/* Phase 2: triger decompression in threads */
	atomic_fetch_add(&phase, 1);

	/* Wait for all threads to decompress their malloc pages */
	while (atomic_load(&thread_thawed_count) != ncpu) {
		sleep(1);
	}

	/* Phase 3: Call into kernel to retrieve vm_info and to get the updated decompressions counter */
	count = TASK_VM_INFO_COUNT;
	err = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t)&vm_info, &count);
	T_EXPECT_EQ(count, TASK_VM_INFO_COUNT, "count == TASK_VM_INFO_COUNT: %d", count);
	T_EXPECT_EQ(0, err, "task_info(TASK_VM_INFO) returned 0");

	/* Make sure this task has decompressed at least all of the dirtied memory */
	T_EXPECT_GE_INT(vm_info.decompressions, npages, "decompressed %d pages (>= heap pages: %d)", vm_info.decompressions, npages);
	T_PASS("Correctly retrieve per-task decompressions stats");

	/* Cleanup */
	join_threads(ncpu, threads);
	free(threads);
	free(targs);
}
Commit	Line	Data
cb323159 A	1	#include <stdlib.h>
	2	#include <stdio.h>
	3	#include <mach/task_info.h>
	4	#include <mach/mach.h>
	5	#include <unistd.h>
	6	#include <signal.h>
	7	#include <errno.h>
	8	#include <sys/kern_memorystatus.h>
	9	#include <sys/sysctl.h>
	10	#include <stdatomic.h>
	11
	12	#include <darwintest.h>
	13	#include <TargetConditionals.h>
	14
	15	#define KB 1024
	16	#define MALLOC_SIZE_PER_THREAD (64 * KB)
	17	#define freezer_path "/usr/local/bin/freeze"
	18
	19	/* BridgeOS could spend more time execv freezer */
	20	#if TARGET_OS_BRIDGE
	21	static int timeout = 600;
	22	#else
	23	static int timeout = 120;
	24	#endif
	25
	26	static _Atomic int thread_malloc_count = 0;
	27	static _Atomic int thread_thawed_count = 0;
	28	static _Atomic int phase = 0;
	29
	30	struct thread_args {
	31	int id;
	32	};
	33
	34	static void
	35	freeze_pid(pid_t pid)
	36	{
	37	char pid_str[6];
	38	char *args[3];
	39	pid_t child_pid;
	40	int status;
	41
	42	sprintf(pid_str, "%d", pid);
	43	child_pid = fork();
	44	if (child_pid == 0) {
	45	/* Launch freezer */
	46	args[0] = freezer_path;
	47	args[1] = pid_str;
	48	args[2] = NULL;
	49	execv(freezer_path, args);
	50	/* execve() does not return on success */
	51	perror("execve");
	52	T_FAIL("execve() failed");
	53	}
	54
	55	/* Wait for freezer to complete */
	56	T_LOG("Waiting for freezer %d to complete", child_pid);
	57	while (0 == waitpid(child_pid, &status, WNOHANG)) {
	58	if (timeout < 0) {
	59	kill(child_pid, SIGKILL);
	60	T_FAIL("Freezer took too long to freeze the test");
	61	}
	62	sleep(1);
	63	timeout--;
	64	}
65	if (WIFEXITED(status) != 1 \|\| WEXITSTATUS(status) != 0) {
66	T_FAIL("Freezer error'd out");
67	}
68	}
69	static void *
70	worker_thread_function(void *args)
71	{
72	struct thread_args *targs = args;
73	int thread_id = targs->id;
74	char *array;
75
76	/* Allocate memory */
77	array = malloc(MALLOC_SIZE_PER_THREAD);
78	T_EXPECT_NOTNULL(array, "thread %d allocated heap memory to be dirtied", thread_id);
79
80	/* Waiting for phase 1 (touch pages) to start */
81	while (atomic_load(&phase) != 1) {
82	;
83	}
84
85	/* Phase 1: touch pages */
86	T_LOG("thread %d phase 1: dirtying %d heap pages (%d bytes)", thread_id, MALLOC_SIZE_PER_THREAD / (int)PAGE_SIZE, MALLOC_SIZE_PER_THREAD);
87	memset(&array[0], 1, MALLOC_SIZE_PER_THREAD);
88	atomic_fetch_add(&thread_malloc_count, 1);
89
90	/* Wait for process to be frozen */
91	while (atomic_load(&phase) != 2) {
92	;
93	}
94
95	/* Phase 2, process thawed, trigger decompressions by re-faulting pages */
96	T_LOG("thread %d phase 2: faulting pages back in to trigger decompressions", thread_id);
97	memset(&array[0], 1, MALLOC_SIZE_PER_THREAD);
98
99	/* Main thread will retrieve vm statistics once all threads are thawed */
100	atomic_fetch_add(&thread_thawed_count, 1);
101
102	free(array);
103
104
105	#if 0 /* Test if the thread's decompressions counter was added to the task decompressions counter when a thread terminates */
106	if (thread_id < 2) {
107	sleep(10);
108	}
109	#endif
110
111	return NULL;
112	}
113
114	static pthread_t*
115	create_threads(int nthreads, pthread_t threads, struct thread_args targs)
116	{
117	int i;
118	int err;
119	pthread_attr_t attr;
120
121	err = pthread_attr_init(&attr);
122	T_ASSERT_POSIX_ZERO(err, "pthread_attr_init");
123	for (i = 0; i < nthreads; i++) {
124	targs[i].id = i;
125	err = pthread_create(&threads[i], &attr, worker_thread_function, (void*)&targs[i]);
126	T_QUIET; T_ASSERT_POSIX_ZERO(err, "pthread_create");
127	}
128
129	return threads;
130	}
131
132	static void
133	join_threads(int nthreads, pthread_t *threads)
134	{
135	int i;
136	int err;
137
138	for (i = 0; i < nthreads; i++) {
139	err = pthread_join(threads[i], NULL);
140	T_QUIET; T_ASSERT_POSIX_ZERO(err, "pthread_join");
141	}
142	}
143
144	T_DECL(task_vm_info_decompressions,
145	"Test multithreaded per-task decompressions counter")
146	{
147	int err;
148	int ncpu;
149	size_t ncpu_size = sizeof(ncpu);
150	int npages;
151	int compressor_mode;
152	size_t compressor_mode_size = sizeof(compressor_mode);
153	task_vm_info_data_t vm_info;
154	mach_msg_type_number_t count;
155	pthread_t *threads;
156	struct thread_args *targs;
157
158	T_SETUPBEGIN;
159
160	/* Make sure freezer is enabled on target machine */
161	err = sysctlbyname("vm.compressor_mode", &compressor_mode, &compressor_mode_size, NULL, 0);
162	if (compressor_mode < 8) {
163	T_SKIP("This test requires freezer which is not available on the testing platform (vm.compressor_mode is set to %d)", compressor_mode);
164	}
165	#if TARGET_OS_BRIDGE
166	T_SKIP("This test requires freezer which is not available on bridgeOS (vm.compressor_mode is set to %d)", compressor_mode);
167	#endif
168
169	/* Set number of threads to ncpu available on testing device */
170	err = sysctlbyname("hw.ncpu", &ncpu, &ncpu_size, NULL, 0);
171	T_EXPECT_EQ_INT(0, err, "Detected %d cpus\n", ncpu);
172
173	/* Set total number of pages to be frozen */
174	npages = ncpu * MALLOC_SIZE_PER_THREAD / (int)PAGE_SIZE;
175	T_LOG("Test will be freezing at least %d heap pages\n", npages);
176
177	/* Change state to freezable */
178	err = memorystatus_control(MEMORYSTATUS_CMD_SET_PROCESS_IS_FREEZABLE, getpid(), (uint32_t)1, NULL, 0);
179	T_EXPECT_EQ(KERN_SUCCESS, err, "set pid %d to be freezable", getpid());
180
181	/* Call into kernel to retrieve vm_info and make sure we do not have any decompressions before the test */
182	count = TASK_VM_INFO_COUNT;
183	err = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t)&vm_info, &count);
184	T_EXPECT_EQ(count, TASK_VM_INFO_COUNT, "count == TASK_VM_INFO_COUNT: %d", count);
185	T_EXPECT_EQ_INT(0, err, "task_info(TASK_VM_INFO) returned 0");
186	T_EXPECT_EQ_INT(0, vm_info.decompressions, "Expected 0 decompressions before test starts");
187
188	/* Thread data */
189	threads = malloc(sizeof(pthread_t) * (size_t)ncpu);
190	targs = malloc(sizeof(struct thread_args) * (size_t)ncpu);
191
192	T_SETUPEND;
193
194	/* Phase 1: create threads to write to malloc memory */
195	create_threads(ncpu, threads, targs);
196	atomic_fetch_add(&phase, 1);
197
198	/* Wait for all threads to dirty their malloc pages */
199	while (atomic_load(&thread_malloc_count) != ncpu) {
200	sleep(1);
201	}
202	T_EXPECT_EQ(ncpu, atomic_load(&thread_malloc_count), "%d threads finished writing to malloc pages\n", ncpu);
203
204	/* Launch freezer to compress the dirty pages */
205	T_LOG("Running freezer to compress pages for pid %d", getpid());
206	freeze_pid(getpid());
207
208	/* Phase 2: triger decompression in threads */
209	atomic_fetch_add(&phase, 1);
210
211	/* Wait for all threads to decompress their malloc pages */
212	while (atomic_load(&thread_thawed_count) != ncpu) {
213	sleep(1);
214	}
215
216	/* Phase 3: Call into kernel to retrieve vm_info and to get the updated decompressions counter */
217	count = TASK_VM_INFO_COUNT;
218	err = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t)&vm_info, &count);
219	T_EXPECT_EQ(count, TASK_VM_INFO_COUNT, "count == TASK_VM_INFO_COUNT: %d", count);
220	T_EXPECT_EQ(0, err, "task_info(TASK_VM_INFO) returned 0");
221
222	/* Make sure this task has decompressed at least all of the dirtied memory */
223	T_EXPECT_GE_INT(vm_info.decompressions, npages, "decompressed %d pages (>= heap pages: %d)", vm_info.decompressions, npages);
224	T_PASS("Correctly retrieve per-task decompressions stats");
225
226	/* Cleanup */
227	join_threads(ncpu, threads);
228	free(threads);
229	free(targs);
230	}