mirror of
https://github.com/darlinghq/darling-libdispatch.git
synced 2024-11-23 12:09:44 +00:00
5bceb4b74b
They were imported from apple/swift-corelibs-libdispatch@34f383d344, so the tests are slightly newer than the actual libdispatch code, but that shouldn't be a problem.
280 lines
8.1 KiB
C
280 lines
8.1 KiB
C
/*
|
|
* Copyright (c) 2008-2011 Apple Inc. All rights reserved.
|
|
*
|
|
* @APPLE_APACHE_LICENSE_HEADER_START@
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* @APPLE_APACHE_LICENSE_HEADER_END@
|
|
*/
|
|
|
|
#include <dispatch/dispatch.h>
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
|
|
#include <spawn.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/time.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#elif defined(_WIN32)
|
|
#include <generic_win_port.h>
|
|
#include <Psapi.h>
|
|
#include <Windows.h>
|
|
#endif
|
|
#include <signal.h>
|
|
#ifdef __APPLE__
|
|
#include <mach/clock_types.h>
|
|
#include <mach-o/arch.h>
|
|
#endif
|
|
|
|
#include <bsdtests.h>
|
|
|
|
#if !defined(_WIN32)
|
|
extern char **environ;
|
|
#endif
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
int res;
|
|
pid_t pid = 0;
|
|
|
|
if (argc < 2) {
|
|
fprintf(stderr, "usage: %s [...]\n", argv[0]);
|
|
exit(1);
|
|
}
|
|
|
|
#ifdef HAVE_POSIX_SPAWNP
|
|
short spawnflags = 0;
|
|
#ifdef __APPLE__
|
|
spawnflags |= POSIX_SPAWN_START_SUSPENDED;
|
|
#if TARGET_OS_EMBEDDED
|
|
spawnflags |= POSIX_SPAWN_SETEXEC;
|
|
#endif
|
|
#endif
|
|
|
|
posix_spawnattr_t attr;
|
|
res = posix_spawnattr_init(&attr);
|
|
assert(res == 0);
|
|
res = posix_spawnattr_setflags(&attr, spawnflags);
|
|
assert(res == 0);
|
|
#endif
|
|
|
|
uint64_t to = 0;
|
|
char *tos = getenv("BSDTEST_TIMEOUT");
|
|
if (tos) {
|
|
to = strtoul(tos, NULL, 0);
|
|
to *= NSEC_PER_SEC;
|
|
}
|
|
|
|
#ifdef __APPLE__
|
|
char *arch = getenv("BSDTEST_ARCH");
|
|
if (arch) {
|
|
const NXArchInfo *ai = NXGetArchInfoFromName(arch);
|
|
if (ai) {
|
|
res = posix_spawnattr_setbinpref_np(&attr, 1, (cpu_type_t*)&ai->cputype, NULL);
|
|
assert(res == 0);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
int i;
|
|
char** newargv = calloc((size_t)argc, sizeof(void*));
|
|
for (i = 1; i < argc; ++i) {
|
|
newargv[i-1] = argv[i];
|
|
}
|
|
newargv[i-1] = NULL;
|
|
|
|
struct timeval tv_start;
|
|
gettimeofday(&tv_start, NULL);
|
|
|
|
#ifdef HAVE_POSIX_SPAWNP
|
|
#ifdef __APPLE__
|
|
if (spawnflags & POSIX_SPAWN_SETEXEC) {
|
|
pid = fork();
|
|
}
|
|
#endif
|
|
if (!pid) {
|
|
res = posix_spawnp(&pid, newargv[0], NULL, &attr, newargv, environ);
|
|
if (res) {
|
|
errno = res;
|
|
perror(newargv[0]);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
#elif defined(__unix__)
|
|
(void)res;
|
|
pid = fork();
|
|
if (pid == -1) {
|
|
perror("fork");
|
|
exit(EXIT_FAILURE);
|
|
} else if (pid == 0) {
|
|
// Child process
|
|
if (execve(newargv[0], newargv, environ) == -1) {
|
|
perror(newargv[0]);
|
|
_Exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
#elif defined(_WIN32)
|
|
(void)res;
|
|
WCHAR *cmdline = argv_to_command_line(newargv);
|
|
if (!cmdline) {
|
|
fprintf(stderr, "argv_to_command_line() failed\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
STARTUPINFOW si = {.cb = sizeof(si)};
|
|
PROCESS_INFORMATION pi;
|
|
BOOL created = CreateProcessW(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
|
|
DWORD error = GetLastError();
|
|
free(cmdline);
|
|
if (!created) {
|
|
print_winapi_error("CreateProcessW", error);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
pid = (pid_t)pi.dwProcessId;
|
|
#else
|
|
#error "bsdtestharness not implemented on this platform"
|
|
#endif
|
|
|
|
//fprintf(stderr, "pid = %d\n", pid);
|
|
assert(pid > 0);
|
|
|
|
#if defined(__linux__)
|
|
int status;
|
|
struct rusage usage;
|
|
struct timeval tv_stop, tv_wall;
|
|
|
|
int res2 = wait4(pid, &status, 0, &usage);
|
|
(void)res2;
|
|
|
|
gettimeofday(&tv_stop, NULL);
|
|
tv_wall.tv_sec = tv_stop.tv_sec - tv_start.tv_sec;
|
|
tv_wall.tv_sec -= (tv_stop.tv_usec < tv_start.tv_usec);
|
|
tv_wall.tv_usec = labs(tv_stop.tv_usec - tv_start.tv_usec);
|
|
|
|
assert(res2 != -1);
|
|
test_long("Process exited", (WIFEXITED(status) && WEXITSTATUS(status) && WEXITSTATUS(status) != 0xff) || WIFSIGNALED(status), 0);
|
|
printf("[PERF]\twall time: %ld.%06ld\n", tv_wall.tv_sec, tv_wall.tv_usec);
|
|
printf("[PERF]\tuser time: %ld.%06ld\n", usage.ru_utime.tv_sec, usage.ru_utime.tv_usec);
|
|
printf("[PERF]\tsystem time: %ld.%06ld\n", usage.ru_stime.tv_sec, usage.ru_stime.tv_usec);
|
|
printf("[PERF]\tmax resident set size: %ld\n", usage.ru_maxrss);
|
|
printf("[PERF]\tpage faults: %ld\n", usage.ru_majflt);
|
|
printf("[PERF]\tswaps: %ld\n", usage.ru_nswap);
|
|
printf("[PERF]\tvoluntary context switches: %ld\n", usage.ru_nvcsw);
|
|
printf("[PERF]\tinvoluntary context switches: %ld\n", usage.ru_nivcsw);
|
|
exit((WIFEXITED(status) && WEXITSTATUS(status)) || WIFSIGNALED(status));
|
|
#elif defined(_WIN32)
|
|
if (WaitForSingleObject(pi.hProcess, INFINITE) != WAIT_OBJECT_0) {
|
|
print_winapi_error("WaitForSingleObject", GetLastError());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
struct timeval tv_stop, tv_wall;
|
|
gettimeofday(&tv_stop, NULL);
|
|
tv_wall.tv_sec = tv_stop.tv_sec - tv_start.tv_sec;
|
|
tv_wall.tv_sec -= (tv_stop.tv_usec < tv_start.tv_usec);
|
|
tv_wall.tv_usec = labs(tv_stop.tv_usec - tv_start.tv_usec);
|
|
|
|
DWORD status;
|
|
if (!GetExitCodeProcess(pi.hProcess, &status)) {
|
|
print_winapi_error("GetExitCodeProcess", GetLastError());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
FILETIME create_time, exit_time, kernel_time, user_time;
|
|
if (!GetProcessTimes(pi.hProcess, &create_time, &exit_time, &kernel_time, &user_time)) {
|
|
print_winapi_error("GetProcessTimes", GetLastError());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
struct timeval utime, stime;
|
|
filetime_to_timeval(&utime, &user_time);
|
|
filetime_to_timeval(&stime, &kernel_time);
|
|
|
|
PROCESS_MEMORY_COUNTERS counters;
|
|
if (!GetProcessMemoryInfo(pi.hProcess, &counters, sizeof(counters))) {
|
|
print_winapi_error("GetProcessMemoryInfo", GetLastError());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
test_long("Process exited", status == 0 || status == 0xff, 1);
|
|
printf("[PERF]\twall time: %ld.%06ld\n", tv_wall.tv_sec, tv_wall.tv_usec);
|
|
printf("[PERF]\tuser time: %ld.%06ld\n", utime.tv_sec, utime.tv_usec);
|
|
printf("[PERF]\tsystem time: %ld.%06ld\n", stime.tv_sec, stime.tv_usec);
|
|
printf("[PERF]\tmax working set size: %zu\n", counters.PeakWorkingSetSize);
|
|
printf("[PERF]\tpage faults: %lu\n", counters.PageFaultCount);
|
|
exit(status ? EXIT_FAILURE : EXIT_SUCCESS);
|
|
#else
|
|
dispatch_queue_t main_q = dispatch_get_main_queue();
|
|
|
|
dispatch_source_t tmp_ds = dispatch_source_create(DISPATCH_SOURCE_TYPE_PROC, pid, DISPATCH_PROC_EXIT, main_q);
|
|
assert(tmp_ds);
|
|
dispatch_source_set_event_handler(tmp_ds, ^{
|
|
int status;
|
|
struct rusage usage;
|
|
struct timeval tv_stop, tv_wall;
|
|
|
|
gettimeofday(&tv_stop, NULL);
|
|
tv_wall.tv_sec = tv_stop.tv_sec - tv_start.tv_sec;
|
|
tv_wall.tv_sec -= (tv_stop.tv_usec < tv_start.tv_usec);
|
|
tv_wall.tv_usec = abs(tv_stop.tv_usec - tv_start.tv_usec);
|
|
|
|
int res2 = wait4(pid, &status, 0, &usage);
|
|
assert(res2 != -1);
|
|
test_long("Process exited", (WIFEXITED(status) && WEXITSTATUS(status) && WEXITSTATUS(status) != 0xff) || WIFSIGNALED(status), 0);
|
|
printf("[PERF]\twall time: %ld.%06d\n", tv_wall.tv_sec, tv_wall.tv_usec);
|
|
printf("[PERF]\tuser time: %ld.%06d\n", usage.ru_utime.tv_sec, usage.ru_utime.tv_usec);
|
|
printf("[PERF]\tsystem time: %ld.%06d\n", usage.ru_stime.tv_sec, usage.ru_stime.tv_usec);
|
|
printf("[PERF]\tmax resident set size: %ld\n", usage.ru_maxrss);
|
|
printf("[PERF]\tpage faults: %ld\n", usage.ru_majflt);
|
|
printf("[PERF]\tswaps: %ld\n", usage.ru_nswap);
|
|
printf("[PERF]\tvoluntary context switches: %ld\n", usage.ru_nvcsw);
|
|
printf("[PERF]\tinvoluntary context switches: %ld\n", usage.ru_nivcsw);
|
|
exit((WIFEXITED(status) && WEXITSTATUS(status)) || WIFSIGNALED(status));
|
|
});
|
|
dispatch_resume(tmp_ds);
|
|
|
|
if (!to) {
|
|
#if TARGET_OS_EMBEDDED
|
|
to = 180LL * NSEC_PER_SEC;
|
|
#else
|
|
to = 90LL * NSEC_PER_SEC;
|
|
#endif
|
|
}
|
|
|
|
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, to), main_q, ^{
|
|
kill(pid, SIGKILL);
|
|
fprintf(stderr, "Terminating unresponsive process (%0.1lfs)\n", (double)to / NSEC_PER_SEC);
|
|
});
|
|
|
|
signal(SIGINT, SIG_IGN);
|
|
tmp_ds = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGINT, 0, main_q);
|
|
assert(tmp_ds);
|
|
dispatch_source_set_event_handler(tmp_ds, ^{
|
|
fprintf(stderr, "Terminating process due to signal\n");
|
|
kill(pid, SIGKILL);
|
|
});
|
|
dispatch_resume(tmp_ds);
|
|
|
|
if (spawnflags & POSIX_SPAWN_SETEXEC) {
|
|
usleep(USEC_PER_SEC/10);
|
|
}
|
|
kill(pid, SIGCONT);
|
|
|
|
dispatch_main();
|
|
#endif
|
|
|
|
return 0;
|
|
}
|