aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.github/workflows/cmake-multi-platform.yml1
-rw-r--r--CMakeLists.txt10
-rw-r--r--README.md46
-rw-r--r--src/cli/stasis/args.c4
-rw-r--r--src/cli/stasis/include/args.h2
-rw-r--r--src/cli/stasis/stasis_main.c15
-rw-r--r--src/lib/core/CMakeLists.txt2
-rw-r--r--src/lib/core/globals.c2
-rw-r--r--src/lib/core/include/copy.h1
-rw-r--r--src/lib/core/include/core.h2
-rw-r--r--src/lib/core/include/multiprocessing.h21
-rw-r--r--src/lib/core/include/sem.h62
-rw-r--r--src/lib/core/include/timespec.h71
-rw-r--r--src/lib/core/include/utils.h6
-rw-r--r--src/lib/core/multiprocessing.c253
-rw-r--r--src/lib/core/semaphore.c71
-rw-r--r--src/lib/core/timespec.c979
-rw-r--r--src/lib/core/utils.c41
-rw-r--r--tests/CMakeLists.txt3
-rw-r--r--tests/include/testing.h9
-rw-r--r--tests/test_multiprocessing.c44
21 files changed, 1541 insertions, 104 deletions
diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml
index ee601b1..055fa0e 100644
--- a/.github/workflows/cmake-multi-platform.yml
+++ b/.github/workflows/cmake-multi-platform.yml
@@ -58,6 +58,7 @@ jobs:
-DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
-DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-DTESTS=ON
+ -DTESTS_VERBOSE=ON
-DTESTS_RT=ON
-DDEBUG_MESSAGES=ON
-S ${{ github.workspace }}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8f5dfa9..074c2ee 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -54,12 +54,22 @@ message(CHECK_START "Run unit tests")
if (TESTS)
message(CHECK_PASS "yes")
enable_testing()
+
+ message(CHECK_START "Verbose test output")
+ option(TESTS_VERBOSE OFF)
+ if (TESTS_VERBOSE)
+ message(CHECK_PASS "yes")
+ else()
+ message(CHECK_PASS "no")
+ endif()
+
message(CHECK_START "Run regression tests")
if (TESTS_RT)
message(CHECK_PASS "yes")
else()
message(CHECK_PASS "no")
endif()
+
add_subdirectory(tests)
else()
message(CHECK_PASS "no")
diff --git a/README.md b/README.md
index 14f7ddb..f6a89bd 100644
--- a/README.md
+++ b/README.md
@@ -147,28 +147,30 @@ stasis mydelivery.ini
## Command Line Options
-| Long Option | Short Option | Purpose |
-|:---------------------------|:------------:|:---------------------------------------------------------------|
-| --help | -h | Display usage statement |
-| --version | -V | Display program version |
-| --continue-on-error | -C | Allow tests to fail |
-| --config ARG | -c ARG | Read STASIS configuration file |
-| --cpu-limit ARG | -l ARG | Number of processes to spawn concurrently (default: cpus - 1) |
-| --pool-status-interval ARG | n/a | Report task status every n seconds (default: 30) |
-| --python ARG | -p ARG | Override version of Python in configuration |
-| --verbose | -v | Increase output verbosity |
-| --unbuffered | -U | Disable line buffering |
-| --update-base | n/a | Update conda installation prior to STATIS environment creation |
-| --fail-fast | n/a | On test error, terminate all tasks |
-| --overwrite | n/a | Overwrite an existing release |
-| --no-docker | n/a | Do not build docker images |
-| --no-artifactory | n/a | Do not upload artifacts to Artifactory |
-| --no-artifactory-build-info| n/a | Do not upload build info objects to Artifactory |
-| --no-artifactory-upload | n/a | Do not upload artifacts to Artifactory (dry-run) |
-| --no-testing | n/a | Do not execute test scripts |
-| --no-parallel | n/a | Do not execute tests in parallel |
-| --no-rewrite | n/a | Do not rewrite paths and URLs in output files |
-| DELIVERY_FILE | n/a | STASIS delivery file |
+| Long Option | Short Option | Purpose |
+|:----------------------------|:------------:|:---------------------------------------------------------------|
+| --help | -h | Display usage statement |
+| --version | -V | Display program version |
+| --continue-on-error | -C | Allow tests to fail |
+| --config ARG | -c ARG | Read STASIS configuration file |
+| --cpu-limit ARG | -l ARG | Number of processes to spawn concurrently (default: cpus - 1) |
+| --pool-status-interval ARG | n/a | Report task status every n seconds (default: 30) |
+| --python ARG | -p ARG | Override version of Python in configuration |
+| --verbose | -v | Increase output verbosity |
+| --unbuffered | -U | Disable line buffering |
+| --update-base | n/a | Update conda installation prior to STATIS environment creation |
+| --fail-fast | n/a | On test error, terminate all tasks |
+| --task-timeout ARG | n/a | Terminate task after timeout is reached (#s, #m, #h) |
+| --overwrite | n/a | Overwrite an existing release |
+| --no-docker | n/a | Do not build docker images |
+| --no-artifactory | n/a | Do not upload artifacts to Artifactory |
+| --no-artifactory-build-info | n/a | Do not upload build info objects to Artifactory |
+| --no-artifactory-upload | n/a | Do not upload artifacts to Artifactory (dry-run) |
+| --no-testing | n/a | Do not execute test scripts |
+| --no-parallel | n/a | Do not execute tests in parallel |
+| --no-task-logging | n/a | Do not log task output (write to stdout) |
+| --no-rewrite | n/a | Do not rewrite paths and URLs in output files |
+| DELIVERY_FILE | n/a | STASIS delivery file |
## Indexer Command Line Options
diff --git a/src/cli/stasis/args.c b/src/cli/stasis/args.c
index f3ce823..172981a 100644
--- a/src/cli/stasis/args.c
+++ b/src/cli/stasis/args.c
@@ -13,6 +13,7 @@ struct option long_options[] = {
{"unbuffered", no_argument, 0, 'U'},
{"update-base", no_argument, 0, OPT_ALWAYS_UPDATE_BASE},
{"fail-fast", no_argument, 0, OPT_FAIL_FAST},
+ {"task-timeout", required_argument, 0, OPT_TASK_TIMEOUT},
{"overwrite", no_argument, 0, OPT_OVERWRITE},
{"no-docker", no_argument, 0, OPT_NO_DOCKER},
{"no-artifactory", no_argument, 0, OPT_NO_ARTIFACTORY},
@@ -20,6 +21,7 @@ struct option long_options[] = {
{"no-artifactory-upload", no_argument, 0, OPT_NO_ARTIFACTORY_UPLOAD},
{"no-testing", no_argument, 0, OPT_NO_TESTING},
{"no-parallel", no_argument, 0, OPT_NO_PARALLEL},
+ {"no-task-logging", no_argument, 0, OPT_NO_TASK_LOGGING},
{"no-rewrite", no_argument, 0, OPT_NO_REWRITE_SPEC_STAGE_2},
{0, 0, 0, 0},
};
@@ -36,6 +38,7 @@ const char *long_options_help[] = {
"Disable line buffering",
"Update conda installation prior to STASIS environment creation",
"On error, immediately terminate all tasks",
+ "Terminate task after timeout is reached (#s, #m, #h)",
"Overwrite an existing release",
"Do not build docker images",
"Do not upload artifacts to Artifactory",
@@ -43,6 +46,7 @@ const char *long_options_help[] = {
"Do not upload artifacts to Artifactory (dry-run)",
"Do not execute test scripts",
"Do not execute tests in parallel",
+ "Do not log task output (write to stdout)",
"Do not rewrite paths and URLs in output files",
NULL,
};
diff --git a/src/cli/stasis/include/args.h b/src/cli/stasis/include/args.h
index 5bad752..5536735 100644
--- a/src/cli/stasis/include/args.h
+++ b/src/cli/stasis/include/args.h
@@ -17,6 +17,8 @@
#define OPT_FAIL_FAST 1009
#define OPT_NO_PARALLEL 1010
#define OPT_POOL_STATUS_INTERVAL 1011
+#define OPT_NO_TASK_LOGGING 1012
+#define OPT_TASK_TIMEOUT 1013
extern struct option long_options[];
void usage(char *progname);
diff --git a/src/cli/stasis/stasis_main.c b/src/cli/stasis/stasis_main.c
index 2ce6831..44ee6d7 100644
--- a/src/cli/stasis/stasis_main.c
+++ b/src/cli/stasis/stasis_main.c
@@ -540,6 +540,18 @@ int main(int argc, char *argv[]) {
case OPT_FAIL_FAST:
globals.parallel_fail_fast = true;
break;
+ case OPT_TASK_TIMEOUT:
+ globals.task_timeout = str_to_timeout(optarg);
+ if (globals.task_timeout < 0) {
+ fprintf(stderr, "Invalid timeout: %s\n", optarg);
+ if (globals.task_timeout == STR_TO_TIMEOUT_INVALID_TIME_SCALE) {
+ fprintf(stderr, "Use format '#s' (seconds), '#m' (minutes), '#h' (hours)\n");
+ } else if (globals.task_timeout == STR_TO_TIMEOUT_NEGATIVE) {
+ fprintf(stderr, "Timeout cannot be negative\n");
+ }
+ exit(1);
+ }
+ break;
case OPT_POOL_STATUS_INTERVAL:
globals.pool_status_interval = (int) strtol(optarg, NULL, 10);
if (globals.pool_status_interval < 1) {
@@ -586,6 +598,9 @@ int main(int argc, char *argv[]) {
case OPT_NO_PARALLEL:
globals.enable_parallel = false;
break;
+ case OPT_NO_TASK_LOGGING:
+ globals.enable_task_logging = false;
+ break;
case '?':
default:
exit(1);
diff --git a/src/lib/core/CMakeLists.txt b/src/lib/core/CMakeLists.txt
index e3e3d4b..eb7a908 100644
--- a/src/lib/core/CMakeLists.txt
+++ b/src/lib/core/CMakeLists.txt
@@ -1,5 +1,6 @@
add_library(stasis_core STATIC
globals.c
+ timespec.c
str.c
strlist.c
ini.c
@@ -21,6 +22,7 @@ add_library(stasis_core STATIC
template_func_proto.c
envctl.c
multiprocessing.c
+ semaphore.c
)
target_include_directories(stasis_core PRIVATE
${core_INCLUDE}
diff --git a/src/lib/core/globals.c b/src/lib/core/globals.c
index d84e799..834213b 100644
--- a/src/lib/core/globals.c
+++ b/src/lib/core/globals.c
@@ -41,8 +41,10 @@ struct STASIS_GLOBAL globals = {
.enable_testing = true, ///< Toggle [test] block "script" execution. "script_setup" always executes.
.enable_rewrite_spec_stage_2 = true, ///< Leave template stings in output files
.enable_parallel = true, ///< Toggle testing in parallel
+ .enable_task_logging = true, ///< Toggle logging for multiprocess tasks
.parallel_fail_fast = false, ///< Kill ALL multiprocessing tasks immediately on error
.pool_status_interval = 30, ///< Report "Task is running"
+ .task_timeout = 0, ///< Time in seconds before task is terminated
};
void globals_free() {
diff --git a/src/lib/core/include/copy.h b/src/lib/core/include/copy.h
index 0f92ddd..1eb5219 100644
--- a/src/lib/core/include/copy.h
+++ b/src/lib/core/include/copy.h
@@ -1,5 +1,6 @@
//! @file copy.h
#ifndef STASIS_COPY_H
+#define STASIS_COPY_H
#include <stdio.h>
#include <stdlib.h>
diff --git a/src/lib/core/include/core.h b/src/lib/core/include/core.h
index 92969d2..5a3fa85 100644
--- a/src/lib/core/include/core.h
+++ b/src/lib/core/include/core.h
@@ -42,6 +42,7 @@ struct STASIS_GLOBAL {
bool enable_overwrite; //!< Enable release file clobbering
bool enable_rewrite_spec_stage_2; //!< Enable automatic @STR@ replacement in output files
bool enable_parallel; //!< Enable testing in parallel
+ bool enable_task_logging; //!< Enable logging task output to a file
long cpu_limit; //!< Limit parallel processing to n cores (default: max - 1)
long parallel_fail_fast; //!< Fail immediately on error
int pool_status_interval; //!< Report "Task is running" every n seconds
@@ -50,6 +51,7 @@ struct STASIS_GLOBAL {
char *tmpdir; //!< Path to temporary storage directory
char *conda_install_prefix; //!< Path to install conda
char *sysconfdir; //!< Path where STASIS reads its configuration files (mission directory, etc)
+ int task_timeout; ///< Time in seconds before task is terminated
struct {
char *tox_posargs;
char *conda_reactivate;
diff --git a/src/lib/core/include/multiprocessing.h b/src/lib/core/include/multiprocessing.h
index ff674e9..874777c 100644
--- a/src/lib/core/include/multiprocessing.h
+++ b/src/lib/core/include/multiprocessing.h
@@ -3,32 +3,36 @@
#define STASIS_MULTIPROCESSING_H
#include "core.h"
+#include "sem.h"
+#include "timespec.h"
#include <signal.h>
#include <sys/wait.h>
-#include <semaphore.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/stat.h>
+#include <math.h>
+
+struct MultiProcessingTimer {
+ struct timespec t_start;
+ struct timespec t_stop;
+ double duration;
+};
struct MultiProcessingTask {
pid_t pid; ///< Program PID
pid_t parent_pid; ///< Program PID (parent process)
int status; ///< Child process exit status
int signaled_by; ///< Last signal received, if any
- time_t _now; ///< Current time
- time_t _seconds; ///< Time elapsed since status interval (used by MultiprocessingPool.status_interval)
+ int timeout; ///< Seconds to elapse before killing the process
time_t _startup; ///< Time elapsed since task started
- long elapsed; ///< Total time elapsed in seconds
char ident[255]; ///< Identity of the pool task
char *cmd; ///< Shell command(s) to be executed
size_t cmd_len; ///< Length of command string (for mmap/munmap)
char working_dir[PATH_MAX]; ///< Path to directory `cmd` should be executed in
char log_file[PATH_MAX]; ///< Full path to stdout/stderr log file
char parent_script[PATH_MAX]; ///< Path to temporary script executing the task
- struct {
- struct timespec t_start;
- struct timespec t_stop;
- } time_data; ///< Wall-time counters
+ struct MultiProcessingTimer time_data; ///< Wall-time counters
+ struct MultiProcessingTimer interval_data; ///< Progress report counters
};
struct MultiProcessingPool {
@@ -38,6 +42,7 @@ struct MultiProcessingPool {
char ident[255]; ///< Identity of task pool
char log_root[PATH_MAX]; ///< Base directory to store stderr/stdout log files
int status_interval; ///< Report a pooled task is "running" every n seconds
+ struct Semaphore semaphore;
};
/// A multiprocessing task's initial state (i.e. "FAIL")
diff --git a/src/lib/core/include/sem.h b/src/lib/core/include/sem.h
new file mode 100644
index 0000000..b8f9a39
--- /dev/null
+++ b/src/lib/core/include/sem.h
@@ -0,0 +1,62 @@
+/**
+* @file sem.h
+*/
+#ifndef STASIS_SEMAPHORE_H
+#define STASIS_SEMAPHORE_H
+
+#include "core.h"
+#include <semaphore.h>
+#if defined(STASIS_OS_DARWIN)
+// Darwin's sem_open() limits the path length to PSEMNAMLEN
+// even though it isn't used directly.
+#include <sys/posix_sem.h> // PSEMNAMLEN
+#endif
+
+struct Semaphore {
+ sem_t *sem;
+ char name[STASIS_NAME_MAX];
+};
+
+/**
+ * Initialize a cross-platform semaphore (Linux/Darwin)
+ *
+ * @code c
+ * #include "sem.h"
+ *
+ * int main(int argc, char *argv[]) {
+ * struct Semaphore s;
+ * if (semaphore_init(&s, "mysem", 1)) {
+ * perror("semaphore_init failed");
+ * exit(1);
+ * }
+ * if (semaphore_wait(&s)) {
+ * perror("semaphore_wait failed");
+ * exit(1);
+ * }
+ *
+ * //
+ * // Critical section
+ * // CODE HERE
+ * //
+ *
+ * if (semaphore_post(&s)) {
+ * perror("semaphore_post failed");
+ * exit(1);
+ * }
+ *
+ * semaphore_destroy(&s);
+ * }
+ * @endcode
+ *
+ * @param s a pointer to `Semaphore`
+ * @param name of the semaphore
+ * @param value initial value of the semaphore
+ * @return -1 on error
+ * @return 0 on success
+ */
+int semaphore_init(struct Semaphore *s, const char *name, int value);
+int semaphore_wait(struct Semaphore *s);
+int semaphore_post(struct Semaphore *s);
+void semaphore_destroy(struct Semaphore *s);
+
+#endif //STASIS_SEMAPHORE_H \ No newline at end of file
diff --git a/src/lib/core/include/timespec.h b/src/lib/core/include/timespec.h
new file mode 100644
index 0000000..3f4b9a7
--- /dev/null
+++ b/src/lib/core/include/timespec.h
@@ -0,0 +1,71 @@
+/* Functions for working with timespec structures
+ * Written by Daniel Collins (2017-2021)
+ * timespec_mod by Alex Forencich (2019)
+ * Various contributions by Ingo Albrecht (2021)
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+*/
+
+#ifndef DAN_TIMESPEC_H
+#define DAN_TIMESPEC_H
+
+#include <stdbool.h>
+#include <sys/time.h>
+#include <time.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct timespec timespec_add(struct timespec ts1, struct timespec ts2);
+struct timespec timespec_sub(struct timespec ts1, struct timespec ts2);
+struct timespec timespec_mod(struct timespec ts1, struct timespec ts2);
+
+struct timespec timespec_min(struct timespec ts1, struct timespec ts2);
+struct timespec timespec_max(struct timespec ts1, struct timespec ts2);
+struct timespec timespec_clamp(struct timespec ts1, struct timespec min, struct timespec max);
+
+int timespec_cmp(struct timespec ts1, struct timespec ts2);
+bool timespec_eq(struct timespec ts1, struct timespec ts2);
+bool timespec_gt(struct timespec ts1, struct timespec ts2);
+bool timespec_ge(struct timespec ts1, struct timespec ts2);
+bool timespec_lt(struct timespec ts1, struct timespec ts2);
+bool timespec_le(struct timespec ts1, struct timespec ts2);
+
+struct timespec timespec_from_double(double s);
+double timespec_to_double(struct timespec ts);
+struct timespec timespec_from_timeval(struct timeval tv);
+struct timeval timespec_to_timeval(struct timespec ts);
+struct timespec timespec_from_ms(long milliseconds);
+long timespec_to_ms(struct timespec ts);
+
+struct timespec timespec_normalise(struct timespec ts);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !DAN_TIMESPEC_H */
diff --git a/src/lib/core/include/utils.h b/src/lib/core/include/utils.h
index a9bcd2f..ea98faf 100644
--- a/src/lib/core/include/utils.h
+++ b/src/lib/core/include/utils.h
@@ -464,4 +464,10 @@ int is_git_sha(char const *hash);
int check_python_package_dependencies(const char *srcdir);
+void seconds_to_human_readable(int v, char *result, size_t maxlen);
+
+#define STR_TO_TIMEOUT_NEGATIVE (-1)
+#define STR_TO_TIMEOUT_INVALID_TIME_SCALE (-2)
+int str_to_timeout(char *s);
+
#endif //STASIS_UTILS_H
diff --git a/src/lib/core/multiprocessing.c b/src/lib/core/multiprocessing.c
index d59a7cd..298484a 100644
--- a/src/lib/core/multiprocessing.c
+++ b/src/lib/core/multiprocessing.c
@@ -4,6 +4,56 @@
/// The sum of all tasks started by mp_task()
size_t mp_global_task_count = 0;
+static double get_duration(const struct timespec stop, const struct timespec start) {
+ const struct timespec result = timespec_sub(stop, start);
+ return timespec_to_double(result);
+}
+
+static double get_task_duration(const struct MultiProcessingTask *task) {
+ const struct timespec *start = &task->time_data.t_start;
+ const struct timespec *stop = &task->time_data.t_stop;
+ return get_duration(*stop, *start);
+}
+
+static double get_task_interval_duration(const struct MultiProcessingTask *task) {
+ const struct timespec *start = &task->interval_data.t_start;
+ const struct timespec *stop = &task->interval_data.t_stop;
+ return get_duration(*stop, *start);
+}
+
+static void update_task_interval_start(struct MultiProcessingTask *task) {
+ // Record the task stop time
+ if (clock_gettime(CLOCK_REALTIME, &task->interval_data.t_start) < 0) {
+ perror("clock_gettime");
+ exit(1);
+ }
+}
+
+static void update_task_interval_elapsed(struct MultiProcessingTask *task) {
+ // Record the interval stop time
+ if (clock_gettime(CLOCK_REALTIME, &task->interval_data.t_stop) < 0) {
+ perror("clock_gettime");
+ exit(1);
+ }
+ task->interval_data.duration = get_task_interval_duration(task);
+}
+
+static void update_task_start(struct MultiProcessingTask *task) {
+ // Record the task start time
+ if (clock_gettime(CLOCK_REALTIME, &task->time_data.t_start) < 0) {
+ perror("clock_gettime");
+ exit(1);
+ }
+}
+static void update_task_elapsed(struct MultiProcessingTask *task) {
+ // Record the task stop time
+ if (clock_gettime(CLOCK_REALTIME, &task->time_data.t_stop) < 0) {
+ perror("clock_gettime");
+ exit(1);
+ }
+ task->time_data.duration = get_task_duration(task);
+}
+
static struct MultiProcessingTask *mp_pool_next_available(struct MultiProcessingPool *pool) {
return &pool->task[pool->num_used];
}
@@ -18,17 +68,14 @@ int child(struct MultiProcessingPool *pool, struct MultiProcessingTask *task) {
exit(1);
}
- // Record the task start time
- if (clock_gettime(CLOCK_REALTIME, &task->time_data.t_start) < 0) {
- perror("clock_gettime");
- exit(1);
- }
-
// Redirect stdout and stderr to the log file
fflush(stdout);
fflush(stderr);
+
// Set log file name
- sprintf(task->log_file + strlen(task->log_file), "task-%zu-%d.log", mp_global_task_count, task->parent_pid);
+ if (globals.enable_task_logging) {
+ sprintf(task->log_file + strlen(task->log_file), "task-%zu-%d.log", mp_global_task_count, task->parent_pid);
+ }
fp_log = freopen(task->log_file, "w+", stdout);
if (!fp_log) {
fprintf(stderr, "unable to open '%s' for writing: %s\n", task->log_file, strerror(errno));
@@ -61,13 +108,18 @@ int child(struct MultiProcessingPool *pool, struct MultiProcessingTask *task) {
}
int parent(struct MultiProcessingPool *pool, struct MultiProcessingTask *task, pid_t pid, int *child_status) {
+ // Record the task start time
+ update_task_start(task);
+
printf("[%s:%s] Task started (pid: %d)\n", pool->ident, task->ident, pid);
// Give the child process access to our PID value
task->pid = pid;
task->parent_pid = pid;
+ semaphore_wait(&pool->semaphore);
mp_global_task_count++;
+ semaphore_post(&pool->semaphore);
// Check child's status
pid_t code = waitpid(pid, child_status, WUNTRACED | WCONTINUED | WNOHANG);
@@ -80,14 +132,22 @@ int parent(struct MultiProcessingPool *pool, struct MultiProcessingTask *task, p
static int mp_task_fork(struct MultiProcessingPool *pool, struct MultiProcessingTask *task) {
SYSDEBUG("Preparing to fork() child task %s:%s", pool->ident, task->ident);
+ semaphore_wait(&pool->semaphore);
pid_t pid = fork();
+ int parent_status = 0;
int child_status = 0;
if (pid == -1) {
return -1;
- } else if (pid == 0) {
+ }
+ if (pid == 0) {
+ semaphore_post(&pool->semaphore);
child(pool, task);
+ } else {
+ parent_status = parent(pool, task, pid, &child_status);
+ fflush(stdout);
+ fflush(stderr);
}
- return parent(pool, task, pid, &child_status);
+ return parent_status;
}
struct MultiProcessingTask *mp_pool_task(struct MultiProcessingPool *pool, const char *ident, char *working_dir, char *cmd) {
@@ -110,8 +170,12 @@ struct MultiProcessingTask *mp_pool_task(struct MultiProcessingPool *pool, const
// Set log file path
memset(slot->log_file, 0, sizeof(*slot->log_file));
- strcat(slot->log_file, pool->log_root);
- strcat(slot->log_file, "/");
+ if (globals.enable_task_logging) {
+ strcat(slot->log_file, pool->log_root);
+ strcat(slot->log_file, "/");
+ } else {
+ strcpy(slot->log_file, "/dev/stdout");
+ }
// Set working directory
if (isempty(working_dir)) {
@@ -152,27 +216,17 @@ struct MultiProcessingTask *mp_pool_task(struct MultiProcessingPool *pool, const
memset(slot->cmd, 0, slot->cmd_len);
strncpy(slot->cmd, cmd, slot->cmd_len);
- return slot;
-}
+ // Set task timeout
+ slot->timeout = globals.task_timeout;
-static void get_task_duration(struct MultiProcessingTask *task, struct timespec *result) {
- // based on the timersub() macro in time.h
- // This implementation uses timespec and increases the resolution from microseconds to nanoseconds.
- struct timespec *start = &task->time_data.t_start;
- struct timespec *stop = &task->time_data.t_stop;
- result->tv_sec = (stop->tv_sec - start->tv_sec);
- result->tv_nsec = (stop->tv_nsec - start->tv_nsec);
- if (result->tv_nsec < 0) {
- --result->tv_sec;
- result->tv_nsec += 1000000000L;
- }
+ return slot;
}
void mp_pool_show_summary(struct MultiProcessingPool *pool) {
print_banner("=", 79);
printf("Pool execution summary for \"%s\"\n", pool->ident);
print_banner("=", 79);
- printf("STATUS PID DURATION IDENT\n");
+ printf("STATUS PID DURATION IDENT\n");
for (size_t i = 0; i < pool->num_used; i++) {
struct MultiProcessingTask *task = &pool->task[i];
char status_str[10] = {0};
@@ -190,10 +244,10 @@ void mp_pool_show_summary(struct MultiProcessingPool *pool) {
strcpy(status_str, "FAIL");
}
- struct timespec duration;
- get_task_duration(task, &duration);
- long diff = duration.tv_sec + duration.tv_nsec / 1000000000L;
- printf("%-4s %10d %7lds %-10s\n", status_str, task->parent_pid, diff, task->ident) ;
+ char duration[255] = {0};
+ seconds_to_human_readable(task->time_data.duration, duration, sizeof(duration));
+ printf("%-4s %10d %10s %-10s\n", status_str, task->parent_pid, duration, task->ident) ;
+ //printf("%-4s %10d %7lds %-10s\n", status_str, task->parent_pid, task->elapsed, task->ident) ;
}
puts("");
}
@@ -209,6 +263,7 @@ static int show_log_contents(FILE *stream, struct MultiProcessingTask *task) {
memset(buf, 0, sizeof(buf));
}
fprintf(stream, "\n");
+ fflush(stream);
fclose(fp);
return 0;
}
@@ -224,32 +279,39 @@ int mp_pool_kill(struct MultiProcessingPool *pool, int signum) {
if (slot->pid > 0) {
int status;
printf("Sending signal %d to task '%s' (pid: %d)\n", signum, slot->ident, slot->pid);
+ semaphore_wait(&pool->semaphore);
status = kill(slot->pid, signum);
+ semaphore_post(&pool->semaphore);
if (status && errno != ESRCH) {
fprintf(stderr, "Task '%s' (pid: %d) did not respond: %s\n", slot->ident, slot->pid, strerror(errno));
} else {
// Wait for process to handle the signal, then set the status accordingly
if (waitpid(slot->pid, &status, 0) >= 0) {
slot->signaled_by = WTERMSIG(status);
- // Record the task stop time
- if (clock_gettime(CLOCK_REALTIME, &slot->time_data.t_stop) < 0) {
- perror("clock_gettime");
- exit(1);
- }
+ semaphore_wait(&pool->semaphore);
+ update_task_elapsed(slot);
+ semaphore_post(&pool->semaphore);
// We are short-circuiting the normal flow, and the process is now dead, so mark it as such
SYSDEBUG("Marking slot %zu: UNUSED", i);
slot->pid = MP_POOL_PID_UNUSED;
}
}
}
- if (!access(slot->log_file, F_OK)) {
- SYSDEBUG("Removing log file: %s", slot->log_file);
- remove(slot->log_file);
+ if (globals.enable_task_logging) {
+ semaphore_wait(&pool->semaphore);
+ if (!access(slot->log_file, F_OK)) {
+ SYSDEBUG("Removing log file: %s", slot->log_file);
+ remove(slot->log_file);
+ }
+ semaphore_post(&pool->semaphore);
}
+
+ semaphore_wait(&pool->semaphore);
if (!access(slot->parent_script, F_OK)) {
SYSDEBUG("Removing runner script: %s", slot->parent_script);
remove(slot->parent_script);
}
+ semaphore_post(&pool->semaphore);
}
return 0;
}
@@ -269,6 +331,7 @@ int mp_pool_join(struct MultiProcessingPool *pool, size_t jobs, size_t flags) {
}
for (size_t i = lower_i; i < upper_i; i++) {
+ char duration[255] = {0};
struct MultiProcessingTask *slot = &pool->task[i];
if (slot->status == MP_POOL_TASK_STATUS_INITIAL) {
slot->_startup = time(NULL);
@@ -296,32 +359,50 @@ int mp_pool_join(struct MultiProcessingPool *pool, size_t jobs, size_t flags) {
// Is the process finished?
pid_t pid = waitpid(slot->pid, &status, WNOHANG | WUNTRACED | WCONTINUED);
- int task_ended = WIFEXITED(status);
- int task_ended_by_signal = WIFSIGNALED(status);
- int task_stopped = WIFSTOPPED(status);
- int task_continued = WIFCONTINUED(status);
- int status_exit = WEXITSTATUS(status);
- int status_signal = WTERMSIG(status);
- int status_stopped = WSTOPSIG(status);
+
+ char progress[1024] = {0};
+ const double percent = ((double) (tasks_complete + 1) / (double) pool->num_used) * 100;
+ snprintf(progress, sizeof(progress) - 1, "[%s:%s] [%3.1f%%]", pool->ident, slot->ident, percent);
+
+ int task_timed_out = false;
+ if (slot->timeout) {
+ task_timed_out = slot->time_data.duration >= (double) slot->timeout;
+ if (task_timed_out && pid == 0 && slot->pid != 0) {
+ seconds_to_human_readable(slot->timeout, duration, sizeof(duration));
+ printf("%s Task timed out after %s (pid: %d)\n", progress, duration, slot->pid);
+ if (kill(slot->pid, SIGKILL) == 0) {
+ status = SIGKILL;
+ } else {
+ SYSERROR("Timeout reached, however pid %d could not be killed.", slot->pid);
+ return -1;
+ }
+ }
+ }
+
+ const int task_ended = WIFEXITED(status);
+ const int task_ended_by_signal = WIFSIGNALED(status);
+ const int task_stopped = WIFSTOPPED(status);
+ const int task_continued = WIFCONTINUED(status);
+ const int status_exit = WEXITSTATUS(status);
+ const int status_signal = WTERMSIG(status);
+ const int status_stopped = WSTOPSIG(status);
// Update status
slot->status = status_exit;
slot->signaled_by = status_signal;
- char progress[1024] = {0};
if (pid > 0) {
- double percent = ((double) (tasks_complete + 1) / (double) pool->num_used) * 100;
- snprintf(progress, sizeof(progress) - 1, "[%s:%s] [%3.1f%%]", pool->ident, slot->ident, percent);
-
// The process ended in one the following ways
// Note: SIGSTOP nor SIGCONT will not increment the tasks_complete counter
if (task_stopped) {
printf("%s Task was suspended (%d)\n", progress, status_stopped);
continue;
- } else if (task_continued) {
+ }
+ if (task_continued) {
printf("%s Task was resumed\n", progress);
continue;
- } else if (task_ended_by_signal) {
+ }
+ if (task_ended_by_signal) {
printf("%s Task ended by signal %d (%s)\n", progress, status_signal, strsignal(status_signal));
tasks_complete++;
} else if (task_ended) {
@@ -331,19 +412,19 @@ int mp_pool_join(struct MultiProcessingPool *pool, size_t jobs, size_t flags) {
fprintf(stderr, "%s Task state is unknown (0x%04X)\n", progress, status);
}
- // Show the log (always)
- if (show_log_contents(stdout, slot)) {
- perror(slot->log_file);
- }
-
- // Record the task stop time
- if (clock_gettime(CLOCK_REALTIME, &slot->time_data.t_stop) < 0) {
- perror("clock_gettime");
- exit(1);
+ if (globals.enable_task_logging) {
+ // Show the log (always)
+ if (show_log_contents(stdout, slot)) {
+ perror(slot->log_file);
+ }
}
if (status >> 8 != 0 || (status & 0xff) != 0) {
- fprintf(stderr, "%s Task failed after %lus\n", progress, slot->elapsed);
+ semaphore_wait(&pool->semaphore);
+ update_task_elapsed(slot);
+ semaphore_post(&pool->semaphore);
+ seconds_to_human_readable(slot->time_data.duration, duration, sizeof(duration));
+ fprintf(stderr, "%s Task failed after %s\n", progress, duration);
failures++;
if (flags & MP_POOL_FAIL_FAST && pool->num_used > 1) {
@@ -351,12 +432,15 @@ int mp_pool_join(struct MultiProcessingPool *pool, size_t jobs, size_t flags) {
return -2;
}
} else {
- printf("%s Task finished after %lus\n", progress, slot->elapsed);
+ seconds_to_human_readable(slot->time_data.duration, duration, sizeof(duration));
+ printf("%s Task finished after %s\n", progress, duration);
}
// Clean up logs and scripts left behind by the task
- if (remove(slot->log_file)) {
- fprintf(stderr, "%s Unable to remove log file: '%s': %s\n", progress, slot->parent_script, strerror(errno));
+ if (globals.enable_task_logging) {
+ if (remove(slot->log_file)) {
+ fprintf(stderr, "%s Unable to remove log file: '%s': %s\n", progress, slot->parent_script, strerror(errno));
+ }
}
if (remove(slot->parent_script)) {
fprintf(stderr, "%s Unable to remove temporary script '%s': %s\n", progress, slot->parent_script, strerror(errno));
@@ -370,17 +454,27 @@ int mp_pool_join(struct MultiProcessingPool *pool, size_t jobs, size_t flags) {
} else {
// Track the number of seconds elapsed for each task.
// When a task has executed for longer than status_intervals, print a status update
- // _seconds represents the time between intervals, not the total runtime of the task
- slot->_seconds = time(NULL) - slot->_now;
- if (slot->_seconds > pool->status_interval) {
- slot->_now = time(NULL);
- slot->_seconds = 0;
+ // interval_elapsed represents the time between intervals, not the total runtime of the task
+ semaphore_wait(&pool->semaphore);
+ if (fabs(slot->interval_data.duration) > pool->status_interval) {
+ slot->interval_data.duration = 0.0;
}
- if (slot->_seconds == 0) {
- printf("[%s:%s] Task is running (pid: %d, elapsed: %lus)\n", pool->ident, slot->ident, slot->parent_pid, slot->elapsed);
+ if (slot->interval_data.duration == 0.0) {
+ seconds_to_human_readable(slot->time_data.duration, duration, sizeof(duration));
+ printf("[%s:%s] Task is running (pid: %d, elapsed: %s)\n",
+ pool->ident, slot->ident, slot->parent_pid, duration);
+ update_task_interval_start(slot);
}
+
+ update_task_interval_elapsed(slot);
+ semaphore_post(&pool->semaphore);
+ }
+
+ if (!task_ended || !task_ended_by_signal) {
+ semaphore_wait(&pool->semaphore);
+ update_task_elapsed(slot);
+ semaphore_post(&pool->semaphore);
}
- slot->elapsed = time(NULL) - slot->_startup;
}
if (tasks_complete == pool->num_used) {
@@ -393,11 +487,12 @@ int mp_pool_join(struct MultiProcessingPool *pool, size_t jobs, size_t flags) {
}
// Poll again after a short delay
- sleep(1);
+ usleep(100000);
} while (1);
pool_deadlocked:
puts("");
+
return failures;
}
@@ -441,12 +536,24 @@ struct MultiProcessingPool *mp_pool_init(const char *ident, const char *log_root
return NULL;
}
+ char semaphore_name[255] = {0};
+ snprintf(semaphore_name, sizeof(semaphore_name), "stasis_mp_%s", ident);
+ if (semaphore_init(&pool->semaphore, semaphore_name, 1) != 0) {
+ fprintf(stderr, "unable to initialize semaphore\n");
+ mp_pool_free(&pool);
+ return NULL;
+ }
+
+ pool->status_interval = 3;
+
return pool;
}
void mp_pool_free(struct MultiProcessingPool **pool) {
- for (size_t i = 0; i < (*pool)->num_alloc; i++) {
+ if (!isempty((*pool)->semaphore.name)) {
+ semaphore_destroy(&(*pool)->semaphore);
}
+
// Unmap all pool tasks
if ((*pool)->task) {
if ((*pool)->task->cmd) {
diff --git a/src/lib/core/semaphore.c b/src/lib/core/semaphore.c
new file mode 100644
index 0000000..579479a
--- /dev/null
+++ b/src/lib/core/semaphore.c
@@ -0,0 +1,71 @@
+/**
+* @file semaphore.c
+*/
+#include <stdio.h>
+#include <fcntl.h>
+
+#include "core_message.h"
+#include "sem.h"
+#include "utils.h"
+
+struct Semaphore *semaphores[1000] = {0};
+bool semaphore_handle_exit_ready = false;
+
+void semaphore_handle_exit() {
+ for (size_t i = 0; i < sizeof(semaphores) / sizeof(*semaphores); ++i) {
+ if (semaphores[i]) {
+ SYSDEBUG("%s", semaphores[i]->name);
+ semaphore_destroy(semaphores[i]);
+ }
+ }
+}
+
+static void register_semaphore(struct Semaphore *s) {
+ struct Semaphore **cur = semaphores;
+ size_t i = 0;
+ while (i < sizeof(semaphores) / sizeof(*semaphores) && cur != NULL) {
+ cur++;
+ i++;
+ }
+ cur = &s;
+}
+
+int semaphore_init(struct Semaphore *s, const char *name, const int value) {
+#if defined(STASIS_OS_DARWIN)
+ // see: sem_open(2)
+ const size_t max_namelen = PSEMNAMLEN;
+#else
+ // see: sem_open(3)
+ const size_t max_namelen = STASIS_NAME_MAX;
+#endif
+ snprintf(s->name, max_namelen, "/%s", name);
+ s->sem = sem_open(s->name, O_CREAT, 0644, value);
+ if (s->sem == SEM_FAILED) {
+ return -1;
+ }
+ SYSDEBUG("%s", s->name);
+ register_semaphore(s);
+ if (!semaphore_handle_exit_ready) {
+ atexit(semaphore_handle_exit);
+ }
+
+ return 0;
+}
+
+int semaphore_wait(struct Semaphore *s) {
+ return sem_wait(s->sem);
+}
+
+int semaphore_post(struct Semaphore *s) {
+ return sem_post(s->sem);
+}
+
+void semaphore_destroy(struct Semaphore *s) {
+ if (!s) {
+ SYSDEBUG("%s", "would have crashed");
+ return;
+ }
+ SYSDEBUG("%s", s->name);
+ sem_close(s->sem);
+ sem_unlink(s->name);
+} \ No newline at end of file
diff --git a/src/lib/core/timespec.c b/src/lib/core/timespec.c
new file mode 100644
index 0000000..bd33993
--- /dev/null
+++ b/src/lib/core/timespec.c
@@ -0,0 +1,979 @@
+/* Functions for working with timespec structures
+ * Written by Daniel Collins (2017-2021)
+ * timespec_mod by Alex Forencich (2019)
+ * Various contributions by Ingo Albrecht (2021)
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+*/
+
+/** \file timespec.c
+ * \brief Functions for working with timespec structures.
+ *
+ * This library aims to provide a comprehensive set of functions with
+ * well-defined behaviour that handle all edge cases (e.g. negative values) in
+ * a sensible manner.
+ *
+ * Negative values are allowed in the tv_sec and/or tv_usec field of timespec
+ * structures, tv_usec is always relative to tv_sec, so mixing positive and
+ * negative values will produce consistent results:
+ *
+ * <PRE>
+ * { tv_sec = 1, tv_nsec = 500000000 } == 1.5 seconds
+ * { tv_sec = 1, tv_nsec = 0 } == 1.0 seconds
+ * { tv_sec = 1, tv_nsec = -500000000 } == 0.5 seconds
+ * { tv_sec = 0, tv_nsec = 500000000 } == 0.5 seconds
+ * { tv_sec = 0, tv_nsec = 0 } == 0.0 seconds
+ * { tv_sec = 0, tv_nsec = -500000000 } == -0.5 seconds
+ * { tv_sec = -1, tv_nsec = 500000000 } == -0.5 seconds
+ * { tv_sec = -1, tv_nsec = 0 } == -1.0 seconds
+ * { tv_sec = -1, tv_nsec = -500000000 } == -1.5 seconds
+ * </PRE>
+ *
+ * Furthermore, any timespec structure processed or returned by library functions
+ * is normalised according to the rules in timespec_normalise().
+*/
+
+#include <limits.h>
+#include <stdbool.h>
+#include <sys/time.h>
+#include <time.h>
+
+#include "timespec.h"
+
+#define NSEC_PER_SEC 1000000000
+
+/** \fn struct timespec timespec_add(struct timespec ts1, struct timespec ts2)
+ * \brief Returns the result of adding two timespec structures.
+*/
+struct timespec timespec_add(struct timespec ts1, struct timespec ts2)
+{
+ /* Normalise inputs to prevent tv_nsec rollover if whole-second values
+ * are packed in it.
+ */
+ ts1 = timespec_normalise(ts1);
+ ts2 = timespec_normalise(ts2);
+
+ ts1.tv_sec += ts2.tv_sec;
+ ts1.tv_nsec += ts2.tv_nsec;
+
+ return timespec_normalise(ts1);
+}
+
+/** \fn struct timespec timespec_sub(struct timespec ts1, struct timespec ts2)
+ * \brief Returns the result of subtracting ts2 from ts1.
+*/
+struct timespec timespec_sub(struct timespec ts1, struct timespec ts2)
+{
+ /* Normalise inputs to prevent tv_nsec rollover if whole-second values
+ * are packed in it.
+ */
+ ts1 = timespec_normalise(ts1);
+ ts2 = timespec_normalise(ts2);
+
+ ts1.tv_sec -= ts2.tv_sec;
+ ts1.tv_nsec -= ts2.tv_nsec;
+
+ return timespec_normalise(ts1);
+}
+
+/** \fn struct timespec timespec_mod(struct timespec ts1, struct timespec ts2)
+ * \brief Returns the remainder left over after dividing ts1 by ts2 (ts1%ts2).
+*/
+struct timespec timespec_mod(struct timespec ts1, struct timespec ts2)
+{
+ int i = 0;
+ bool neg1 = false;
+ bool neg2 = false;
+
+ /* Normalise inputs to prevent tv_nsec rollover if whole-second values
+ * are packed in it.
+ */
+ ts1 = timespec_normalise(ts1);
+ ts2 = timespec_normalise(ts2);
+
+ /* If ts2 is zero, just return ts1
+ */
+ if (ts2.tv_sec == 0 && ts2.tv_nsec == 0)
+ {
+ return ts1;
+ }
+
+ /* If inputs are negative, flip and record sign
+ */
+ if (ts1.tv_sec < 0 || ts1.tv_nsec < 0)
+ {
+ neg1 = true;
+ ts1.tv_sec = -ts1.tv_sec;
+ ts1.tv_nsec = -ts1.tv_nsec;
+ }
+
+ if (ts2.tv_sec < 0 || ts2.tv_nsec < 0)
+ {
+ neg2 = true;
+ ts2.tv_sec = -ts2.tv_sec;
+ ts2.tv_nsec = -ts2.tv_nsec;
+ }
+
+ /* Shift ts2 until it is larger than ts1 or is about to overflow
+ */
+ while ((ts2.tv_sec < (LONG_MAX >> 1)) && timespec_ge(ts1, ts2))
+ {
+ i++;
+ ts2.tv_nsec <<= 1;
+ ts2.tv_sec <<= 1;
+ if (ts2.tv_nsec > NSEC_PER_SEC)
+ {
+ ts2.tv_nsec -= NSEC_PER_SEC;
+ ts2.tv_sec++;
+ }
+ }
+
+ /* Division by repeated subtraction
+ */
+ while (i >= 0)
+ {
+ if (timespec_ge(ts1, ts2))
+ {
+ ts1 = timespec_sub(ts1, ts2);
+ }
+
+ if (i == 0)
+ {
+ break;
+ }
+
+ i--;
+ if (ts2.tv_sec & 1)
+ {
+ ts2.tv_nsec += NSEC_PER_SEC;
+ }
+ ts2.tv_nsec >>= 1;
+ ts2.tv_sec >>= 1;
+ }
+
+ /* If signs differ and result is nonzero, subtract once more to cross zero
+ */
+ if (neg1 ^ neg2 && (ts1.tv_sec != 0 || ts1.tv_nsec != 0))
+ {
+ ts1 = timespec_sub(ts1, ts2);
+ }
+
+ /* Restore sign
+ */
+ if (neg1)
+ {
+ ts1.tv_sec = -ts1.tv_sec;
+ ts1.tv_nsec = -ts1.tv_nsec;
+ }
+
+ return ts1;
+}
+
+/** \fn struct timespec timespec_min(struct timespec ts1, struct timespec ts2)
+ * \brief Return the lesser one of the two given timespec values.
+*/
+struct timespec timespec_min(struct timespec ts1, struct timespec ts2) {
+ if(timespec_le(ts1, ts2)) {
+ return ts1;
+ } else {
+ return ts2;
+ }
+}
+
+/** \fn struct timespec timespec_max(struct timespec ts1, struct timespec ts2)
+ * \brief Return the greater one of the two given timespec values.
+*/
+struct timespec timespec_max(struct timespec ts1, struct timespec ts2) {
+ if(timespec_ge(ts1, ts2)) {
+ return ts1;
+ } else {
+ return ts2;
+ }
+}
+
+/** \fn struct timespec timespec_clamp(struct timespec ts, struct timespec min, struct timespec max)
+ * \brief Clamp the value of TS between MIN and MAX.
+*/
+struct timespec timespec_clamp(struct timespec ts, struct timespec min, struct timespec max) {
+ if(timespec_gt(ts, max)) {
+ return max;
+ }
+ if(timespec_lt(ts, min)) {
+ return min;
+ }
+ return ts;
+}
+
+/** \fn int timespec_cmp(struct timespec ts1, struct timespec ts2)
+ * \brief Returns (1, 0, -1) if ts1 is (greater than, equal to, less than) to ts2.
+*/
+int timespec_cmp(struct timespec ts1, struct timespec ts2)
+{
+ ts1 = timespec_normalise(ts1);
+ ts2 = timespec_normalise(ts2);
+
+ if(ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec == ts2.tv_nsec)
+ {
+ return 0;
+ }
+ else if((ts1.tv_sec > ts2.tv_sec)
+ || (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec > ts2.tv_nsec))
+ {
+ return 1;
+ }
+ else {
+ return -1;
+ }
+}
+
+/** \fn bool timespec_eq(struct timespec ts1, struct timespec ts2)
+ * \brief Returns true if the two timespec structures are equal.
+*/
+bool timespec_eq(struct timespec ts1, struct timespec ts2)
+{
+ ts1 = timespec_normalise(ts1);
+ ts2 = timespec_normalise(ts2);
+
+ return (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec == ts2.tv_nsec);
+}
+
+/** \fn bool timespec_gt(struct timespec ts1, struct timespec ts2)
+ * \brief Returns true if ts1 is greater than ts2.
+*/
+bool timespec_gt(struct timespec ts1, struct timespec ts2)
+{
+ ts1 = timespec_normalise(ts1);
+ ts2 = timespec_normalise(ts2);
+
+ return (ts1.tv_sec > ts2.tv_sec || (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec > ts2.tv_nsec));
+}
+
+/** \fn bool timespec_ge(struct timespec ts1, struct timespec ts2)
+ * \brief Returns true if ts1 is greater than or equal to ts2.
+*/
+bool timespec_ge(struct timespec ts1, struct timespec ts2)
+{
+ ts1 = timespec_normalise(ts1);
+ ts2 = timespec_normalise(ts2);
+
+ return (ts1.tv_sec > ts2.tv_sec || (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec >= ts2.tv_nsec));
+}
+
+/** \fn bool timespec_lt(struct timespec ts1, struct timespec ts2)
+ * \brief Returns true if ts1 is less than ts2.
+*/
+bool timespec_lt(struct timespec ts1, struct timespec ts2)
+{
+ ts1 = timespec_normalise(ts1);
+ ts2 = timespec_normalise(ts2);
+
+ return (ts1.tv_sec < ts2.tv_sec || (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec < ts2.tv_nsec));
+}
+
+/** \fn bool timespec_le(struct timespec ts1, struct timespec ts2)
+ * \brief Returns true if ts1 is less than or equal to ts2.
+*/
+bool timespec_le(struct timespec ts1, struct timespec ts2)
+{
+ ts1 = timespec_normalise(ts1);
+ ts2 = timespec_normalise(ts2);
+
+ return (ts1.tv_sec < ts2.tv_sec || (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec <= ts2.tv_nsec));
+}
+
+/** \fn struct timespec timespec_from_double(double s)
+ * \brief Converts a fractional number of seconds to a timespec.
+*/
+struct timespec timespec_from_double(double s)
+{
+ struct timespec ts = {
+ .tv_sec = s,
+ .tv_nsec = (s - (long)(s)) * NSEC_PER_SEC,
+ };
+
+ return timespec_normalise(ts);
+}
+
+/** \fn double timespec_to_double(struct timespec ts)
+ * \brief Converts a timespec to a fractional number of seconds.
+*/
+double timespec_to_double(struct timespec ts)
+{
+ return ((double)(ts.tv_sec) + ((double)(ts.tv_nsec) / NSEC_PER_SEC));
+}
+
+/** \fn struct timespec timespec_from_timeval(struct timeval tv)
+ * \brief Converts a timeval to a timespec.
+*/
+struct timespec timespec_from_timeval(struct timeval tv)
+{
+ struct timespec ts = {
+ .tv_sec = tv.tv_sec,
+ .tv_nsec = tv.tv_usec * 1000
+ };
+
+ return timespec_normalise(ts);
+}
+
+/** \fn struct timeval timespec_to_timeval(struct timespec ts)
+ * \brief Converts a timespec to a timeval.
+*/
+struct timeval timespec_to_timeval(struct timespec ts)
+{
+ ts = timespec_normalise(ts);
+
+ struct timeval tv = {
+ .tv_sec = ts.tv_sec,
+ .tv_usec = ts.tv_nsec / 1000,
+ };
+
+ return tv;
+}
+
+/** \fn struct timespec timespec_from_ms(long milliseconds)
+ * \brief Converts an integer number of milliseconds to a timespec.
+*/
+struct timespec timespec_from_ms(long milliseconds)
+{
+ struct timespec ts = {
+ .tv_sec = (milliseconds / 1000),
+ .tv_nsec = (milliseconds % 1000) * 1000000,
+ };
+
+ return timespec_normalise(ts);
+}
+
+/** \fn long timespec_to_ms(struct timespec ts)
+ * \brief Converts a timespec to an integer number of milliseconds.
+*/
+long timespec_to_ms(struct timespec ts)
+{
+ return (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
+}
+
+/** \fn struct timespec timespec_normalise(struct timespec ts)
+ * \brief Normalises a timespec structure.
+ *
+ * Returns a normalised version of a timespec structure, according to the
+ * following rules:
+ *
+ * 1) If tv_nsec is >=1,000,000,00 or <=-1,000,000,000, flatten the surplus
+ * nanoseconds into the tv_sec field.
+ *
+ * 2) If tv_nsec is negative, decrement tv_sec and roll tv_nsec up to represent
+ * the same value attainable by ADDING nanoseconds to tv_sec.
+*/
+struct timespec timespec_normalise(struct timespec ts)
+{
+ while(ts.tv_nsec >= NSEC_PER_SEC)
+ {
+ ++(ts.tv_sec);
+ ts.tv_nsec -= NSEC_PER_SEC;
+ }
+
+ while(ts.tv_nsec <= -NSEC_PER_SEC)
+ {
+ --(ts.tv_sec);
+ ts.tv_nsec += NSEC_PER_SEC;
+ }
+
+ if(ts.tv_nsec < 0)
+ {
+ /* Negative nanoseconds isn't valid according to POSIX.
+ * Decrement tv_sec and roll tv_nsec over.
+ */
+
+ --(ts.tv_sec);
+ ts.tv_nsec = (NSEC_PER_SEC + ts.tv_nsec);
+ }
+
+ return ts;
+}
+
+#ifdef TEST
+#include <stdio.h>
+
+#define TEST_NORMALISE(ts_sec, ts_nsec, expect_sec, expect_nsec) { \
+ struct timespec in = { .tv_sec = ts_sec, .tv_nsec = ts_nsec }; \
+ struct timespec got = timespec_normalise(in); \
+ if(got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) \
+ { \
+ printf("%s:%d: timespec_normalise({%ld, %ld}) returned wrong values\n", __FILE__, __LINE__, \
+ (long)(ts_sec), (long)(ts_nsec)); \
+ printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), (long)(expect_nsec)); \
+ printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), (long)(got.tv_nsec)); \
+ ++result; \
+ } \
+}
+
+#define TEST_BINOP(func, ts1_sec, ts1_nsec, ts2_sec, ts2_nsec, expect_sec, expect_nsec) { \
+ struct timespec ts1 = { .tv_sec = ts1_sec, .tv_nsec = ts1_nsec }; \
+ struct timespec ts2 = { .tv_sec = ts2_sec, .tv_nsec = ts2_nsec }; \
+ struct timespec got = func(ts1, ts2); \
+ if(got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) \
+ { \
+ printf(#func "({%ld, %ld}, {%ld, %ld}) returned wrong values\n", \
+ (long)(ts1_sec), (long)(ts1_nsec), (long)(ts2_sec), (long)(ts2_nsec)); \
+ printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), (long)(expect_nsec)); \
+ printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), (long)(got.tv_nsec)); \
+ ++result; \
+ } \
+}
+
+#define TEST_TRINOP(func, ts1_sec, ts1_nsec, ts2_sec, ts2_nsec, ts3_sec, ts3_nsec, expect_sec, expect_nsec) { \
+ struct timespec ts1 = { .tv_sec = ts1_sec, .tv_nsec = ts1_nsec }; \
+ struct timespec ts2 = { .tv_sec = ts2_sec, .tv_nsec = ts2_nsec }; \
+ struct timespec ts3 = { .tv_sec = ts3_sec, .tv_nsec = ts3_nsec }; \
+ struct timespec got = func(ts1, ts2, ts3); \
+ if(got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) \
+ { \
+ printf(#func "({%ld, %ld}, {%ld, %ld}, {%ld, %ld}) returned wrong values\n", \
+ (long)(ts1_sec), (long)(ts1_nsec), \
+ (long)(ts2_sec), (long)(ts2_nsec), \
+ (long)(ts3_sec), (long)(ts3_nsec)); \
+ printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), (long)(expect_nsec)); \
+ printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), (long)(got.tv_nsec)); \
+ ++result; \
+ } \
+}
+
+#define TEST_TEST_FUNC(func, ts1_sec, ts1_nsec, ts2_sec, ts2_nsec, expect) { \
+ struct timespec ts1 = { .tv_sec = ts1_sec, .tv_nsec = ts1_nsec }; \
+ struct timespec ts2 = { .tv_sec = ts2_sec, .tv_nsec = ts2_nsec }; \
+ int got = func(ts1, ts2); \
+ if(got != expect) \
+ { \
+ printf("%s:%d: " #func "({%ld, %ld}, {%ld, %ld}) returned %d, expected %s\n", __FILE__, __LINE__, \
+ (long)(ts1_sec), (long)(ts1_nsec), (long)(ts2_sec), (long)(ts2_nsec), \
+ got, #expect); \
+ ++result; \
+ } \
+}
+
+#define TEST_FROM_DOUBLE(d_secs, expect_sec, expect_nsec) { \
+ struct timespec got = timespec_from_double(d_secs); \
+ if(got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) \
+ { \
+ printf("%s:%d: timespec_from_double(%f) returned wrong values\n", __FILE__, __LINE__, (double)(d_secs)); \
+ printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), (long)(expect_nsec)); \
+ printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), (long)(got.tv_nsec)); \
+ ++result; \
+ } \
+}
+
+#define TEST_TO_DOUBLE(ts_sec, ts_nsec, expect) { \
+ struct timespec ts = { .tv_sec = ts_sec, .tv_nsec = ts_nsec }; \
+ double got = timespec_to_double(ts); \
+ if(got != expect) { \
+ printf("%s:%d: timespec_to_double({%ld, %ld}) returned wrong value\n", __FILE__, __LINE__, \
+ (long)(ts_sec), (long)(ts_nsec)); \
+ printf(" Expected: %f\n", (double)(expect)); \
+ printf(" Got: %f\n", got); \
+ ++result; \
+ } \
+}
+
+#define TEST_FROM_TIMEVAL(in_sec, in_usec, expect_sec, expect_nsec) { \
+ struct timeval tv = { .tv_sec = in_sec, .tv_usec = in_usec }; \
+ struct timespec got = timespec_from_timeval(tv); \
+ if(got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) \
+ { \
+ printf("%s:%d: timespec_from_timeval({%ld, %ld}) returned wrong values\n", __FILE__, __LINE__, \
+ (long)(in_sec), (long)(in_usec)); \
+ printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), (long)(expect_nsec)); \
+ printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), (long)(got.tv_nsec)); \
+ ++result; \
+ } \
+}
+
+#define TEST_TO_TIMEVAL(ts_sec, ts_nsec, expect_sec, expect_usec) { \
+ struct timespec ts = { .tv_sec = ts_sec, .tv_nsec = ts_nsec }; \
+ struct timeval got = timespec_to_timeval(ts); \
+ if(got.tv_sec != expect_sec || got.tv_usec != expect_usec) \
+ { \
+ printf("%s:%d: timespec_to_timeval({%ld, %ld}) returned wrong values\n", __FILE__, __LINE__, \
+ (long)(ts_sec), (long)(ts_nsec)); \
+ printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), (long)(expect_usec)); \
+ printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), (long)(got.tv_usec)); \
+ ++result; \
+ } \
+}
+
+#define TEST_FROM_MS(msecs, expect_sec, expect_nsec) { \
+ struct timespec got = timespec_from_ms(msecs); \
+ if(got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) \
+ { \
+ printf("%s:%d: timespec_from_ms(%ld) returned wrong values\n", __FILE__, __LINE__, (long)(msecs)); \
+ printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), (long)(expect_nsec)); \
+ printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), (long)(got.tv_nsec)); \
+ ++result; \
+ } \
+}
+
+#define TEST_TO_MS(ts_sec, ts_nsec, expect) { \
+ struct timespec ts = { .tv_sec = ts_sec, .tv_nsec = ts_nsec }; \
+ long got = timespec_to_ms(ts); \
+ if(got != expect) { \
+ printf("%s:%d: timespec_to_ms({%ld, %ld}) returned wrong value\n", __FILE__, __LINE__, \
+ (long)(ts_sec), (long)(ts_nsec)); \
+ printf(" Expected: %ld\n", (long)(expect)); \
+ printf(" Got: %ld\n", got); \
+ ++result; \
+ } \
+}
+
+int main()
+{
+ int result = 0;
+
+ // timespec_add
+
+ TEST_BINOP(timespec_add, 0,0, 0,0, 0,0);
+ TEST_BINOP(timespec_add, 0,0, 1,0, 1,0);
+ TEST_BINOP(timespec_add, 1,0, 0,0, 1,0);
+ TEST_BINOP(timespec_add, 1,0, 1,0, 2,0);
+ TEST_BINOP(timespec_add, 1,500000000, 1,0, 2,500000000);
+ TEST_BINOP(timespec_add, 1,0, 1,500000000, 2,500000000);
+ TEST_BINOP(timespec_add, 1,500000000, 1,500000000, 3,0);
+ TEST_BINOP(timespec_add, 1,500000000, 1,499999999, 2,999999999);
+ TEST_BINOP(timespec_add, 1,500000000, 1,500000000, 3,0);
+ TEST_BINOP(timespec_add, 1,999999999, 1,999999999, 3,999999998);
+ TEST_BINOP(timespec_add, 0,500000000, 1,500000000, 2,0);
+ TEST_BINOP(timespec_add, 1,500000000, 0,500000000, 2,0);
+
+ // timespec_sub
+
+ TEST_BINOP(timespec_sub, 0,0, 0,0, 0,0);
+ TEST_BINOP(timespec_sub, 1,0, 0,0, 1,0);
+ TEST_BINOP(timespec_sub, 1,0, 1,0, 0,0);
+ TEST_BINOP(timespec_sub, 1,500000000, 0,500000000, 1,0);
+ TEST_BINOP(timespec_sub, 5,500000000, 2,999999999, 2,500000001);
+ TEST_BINOP(timespec_sub, 0,0, 1,0, -1,0);
+ TEST_BINOP(timespec_sub, 0,500000000, 1,500000000, -1,0);
+ TEST_BINOP(timespec_sub, 0,0, 1,500000000, -2,500000000);
+ TEST_BINOP(timespec_sub, 1,0, 1,500000000, -1,500000000);
+ TEST_BINOP(timespec_sub, 1,0, 1,499999999, -1,500000001);
+
+ // timespec_mod
+
+ TEST_BINOP(timespec_mod, 0,0, 0,0, 0,0);
+ TEST_BINOP(timespec_mod, 0,0, 1,0, 0,0);
+ TEST_BINOP(timespec_mod, 1,0, 0,0, 1,0);
+ TEST_BINOP(timespec_mod, 1,0, 1,0, 0,0);
+ TEST_BINOP(timespec_mod, 10,0, 1,0, 0,0);
+ TEST_BINOP(timespec_mod, 10,0, 3,0, 1,0);
+ TEST_BINOP(timespec_mod, 10,0, -3,0, -2,0);
+ TEST_BINOP(timespec_mod, -10,0, 3,0, 2,0);
+ TEST_BINOP(timespec_mod, -10,0, -3,0, -1,0);
+ TEST_BINOP(timespec_mod, 10,0, 5,0, 0,0);
+ TEST_BINOP(timespec_mod, 10,0, -5,0, 0,0);
+ TEST_BINOP(timespec_mod, -10,0, 5,0, 0,0);
+ TEST_BINOP(timespec_mod, -10,0, -5,0, 0,0);
+ TEST_BINOP(timespec_mod, 1,500000000, 0,500000000, 0,0);
+ TEST_BINOP(timespec_mod, 5,500000000, 2,999999999, 2,500000001);
+ TEST_BINOP(timespec_mod, 0,500000000, 1,500000000, 0,500000000);
+ TEST_BINOP(timespec_mod, 0,0, 1,500000000, 0,0);
+ TEST_BINOP(timespec_mod, 1,0, 1,500000000, 1,0);
+ TEST_BINOP(timespec_mod, 1,0, 0,1, 0,0);
+ TEST_BINOP(timespec_mod, 1,123456789, 0,1000, 0,789);
+ TEST_BINOP(timespec_mod, 1,0, 0,9999999, 0,100);
+ TEST_BINOP(timespec_mod, 12345,54321, 0,100001, 0,5555);
+ TEST_BINOP(timespec_mod, LONG_MAX,0, 0,1, 0,0);
+ TEST_BINOP(timespec_mod, LONG_MAX,0, LONG_MAX,1, LONG_MAX,0);
+
+ // timespec_clamp
+
+ TEST_TRINOP(timespec_clamp, 0,0, 0,0, 0,0, 0,0);
+
+ TEST_TRINOP(timespec_clamp, 1000,0, 2000,0, 3000,0, 2000,0);
+ TEST_TRINOP(timespec_clamp, 1500,0, 2000,0, 3000,0, 2000,0);
+ TEST_TRINOP(timespec_clamp, 1999,0, 2000,0, 3000,0, 2000,0);
+ TEST_TRINOP(timespec_clamp, 2000,0, 2000,0, 3000,0, 2000,0);
+ TEST_TRINOP(timespec_clamp, 2001,0, 2000,0, 3000,0, 2001,0);
+ TEST_TRINOP(timespec_clamp, 2250,0, 2000,0, 3000,0, 2250,0);
+ TEST_TRINOP(timespec_clamp, 2500,0, 2000,0, 3000,0, 2500,0);
+ TEST_TRINOP(timespec_clamp, 2750,0, 2000,0, 3000,0, 2750,0);
+ TEST_TRINOP(timespec_clamp, 2999,0, 2000,0, 3000,0, 2999,0);
+ TEST_TRINOP(timespec_clamp, 3000,0, 2000,0, 3000,0, 3000,0);
+ TEST_TRINOP(timespec_clamp, 3001,0, 2000,0, 3000,0, 3000,0);
+ TEST_TRINOP(timespec_clamp, 3500,0, 2000,0, 3000,0, 3000,0);
+ TEST_TRINOP(timespec_clamp, 4000,0, 2000,0, 3000,0, 3000,0);
+
+ TEST_TRINOP(timespec_clamp, 0,1000, 0,2000, 0,3000, 0,2000);
+ TEST_TRINOP(timespec_clamp, 0,1500, 0,2000, 0,3000, 0,2000);
+ TEST_TRINOP(timespec_clamp, 0,1999, 0,2000, 0,3000, 0,2000);
+ TEST_TRINOP(timespec_clamp, 0,2000, 0,2000, 0,3000, 0,2000);
+ TEST_TRINOP(timespec_clamp, 0,2001, 0,2000, 0,3000, 0,2001);
+ TEST_TRINOP(timespec_clamp, 0,2250, 0,2000, 0,3000, 0,2250);
+ TEST_TRINOP(timespec_clamp, 0,2500, 0,2000, 0,3000, 0,2500);
+ TEST_TRINOP(timespec_clamp, 0,2750, 0,2000, 0,3000, 0,2750);
+ TEST_TRINOP(timespec_clamp, 0,2999, 0,2000, 0,3000, 0,2999);
+ TEST_TRINOP(timespec_clamp, 0,3000, 0,2000, 0,3000, 0,3000);
+ TEST_TRINOP(timespec_clamp, 0,3001, 0,2000, 0,3000, 0,3000);
+ TEST_TRINOP(timespec_clamp, 0,3500, 0,2000, 0,3000, 0,3000);
+ TEST_TRINOP(timespec_clamp, 0,4000, 0,2000, 0,3000, 0,3000);
+
+ TEST_TRINOP(timespec_clamp,0,-1000, 0,-3000, 0,-2000, 0,-2000);
+ TEST_TRINOP(timespec_clamp,0,-1500, 0,-3000, 0,-2000, 0,-2000);
+ TEST_TRINOP(timespec_clamp,0,-1999, 0,-3000, 0,-2000, 0,-2000);
+ TEST_TRINOP(timespec_clamp,0,-3000, 0,-3000, 0,-2000, 0,-3000);
+ TEST_TRINOP(timespec_clamp,0,-2001, 0,-3000, 0,-2000, 0,-2001);
+ TEST_TRINOP(timespec_clamp,0,-2250, 0,-3000, 0,-2000, 0,-2250);
+ TEST_TRINOP(timespec_clamp,0,-2500, 0,-3000, 0,-2000, 0,-2500);
+ TEST_TRINOP(timespec_clamp,0,-2750, 0,-3000, 0,-2000, 0,-2750);
+ TEST_TRINOP(timespec_clamp,0,-2999, 0,-3000, 0,-2000, 0,-2999);
+ TEST_TRINOP(timespec_clamp,0,-2000, 0,-3000, 0,-2000, 0,-2000);
+ TEST_TRINOP(timespec_clamp,0,-3001, 0,-3000, 0,-2000, 0,-3000);
+ TEST_TRINOP(timespec_clamp,0,-3500, 0,-3000, 0,-2000, 0,-3000);
+ TEST_TRINOP(timespec_clamp,0,-2000, 0,-3000, 0,-2000, 0,-2000);
+
+ TEST_TRINOP(timespec_clamp,0,-4000, 0,-3000, 0,3000, 0,-3000);
+ TEST_TRINOP(timespec_clamp,0,-3001, 0,-3000, 0,3000, 0,-3000);
+ TEST_TRINOP(timespec_clamp,0,-3000, 0,-3000, 0,3000, 0,-3000);
+ TEST_TRINOP(timespec_clamp,0,-2999, 0,-3000, 0,3000, 0,-2999);
+ TEST_TRINOP(timespec_clamp,0,-1500, 0,-3000, 0,3000, 0,-1500);
+ TEST_TRINOP(timespec_clamp,0, -1, 0,-3000, 0,3000, 0, -1);
+ TEST_TRINOP(timespec_clamp,0, 0, 0,-3000, 0,3000, 0, 0);
+ TEST_TRINOP(timespec_clamp,0, 1, 0,-3000, 0,3000, 0, 1);
+ TEST_TRINOP(timespec_clamp,0, 1500, 0,-3000, 0,3000, 0, 1500);
+ TEST_TRINOP(timespec_clamp,0, 2999, 0,-3000, 0,3000, 0, 2999);
+ TEST_TRINOP(timespec_clamp,0, 3000, 0,-3000, 0,3000, 0, 3000);
+ TEST_TRINOP(timespec_clamp,0, 3001, 0,-3000, 0,3000, 0, 3000);
+ TEST_TRINOP(timespec_clamp,0, 4000, 0,-3000, 0,3000, 0, 3000);
+
+ // timespec_min
+
+ TEST_BINOP(timespec_min, 0,0, 0,0, 0,0);
+ TEST_BINOP(timespec_min, 0,0, 1,0, 0,0);
+ TEST_BINOP(timespec_min, 1,0, 0,0, 0,0);
+ TEST_BINOP(timespec_min, 1,0, 1,0, 1,0);
+ TEST_BINOP(timespec_min, 10,0, 1,0, 1,0);
+ TEST_BINOP(timespec_min, 10,0, 3,0, 3,0);
+ TEST_BINOP(timespec_min, 10,0, -3,0, -3,0);
+ TEST_BINOP(timespec_min, -10,0, 3,0, -10,0);
+ TEST_BINOP(timespec_min, -10,0, -3,0, -10,0);
+ TEST_BINOP(timespec_min, 10,0, 5,0, 5,0);
+ TEST_BINOP(timespec_min, 10,0, -5,0, -5,0);
+ TEST_BINOP(timespec_min, -10,0, 5,0, -10,0);
+ TEST_BINOP(timespec_min, -10,0, -5,0, -10,0);
+ TEST_BINOP(timespec_min, 1,500000000, 0,500000000, 0,500000000);
+ TEST_BINOP(timespec_min, 5,500000000, 2,999999999, 2,999999999);
+ TEST_BINOP(timespec_min, 0,500000000, 1,500000000, 0,500000000);
+ TEST_BINOP(timespec_min, 0,0, 1,500000000, 0,0);
+ TEST_BINOP(timespec_min, 1,0, 1,500000000, 1,0);
+ TEST_BINOP(timespec_min, 1,0, 0,1, 0,1);
+ TEST_BINOP(timespec_min, 1,123456789, 0,1000, 0,1000);
+ TEST_BINOP(timespec_min, 1,0, 0,9999999, 0,9999999);
+ TEST_BINOP(timespec_min, 12345,54321, 0,100001, 0,100001);
+ TEST_BINOP(timespec_min, LONG_MIN,0, 0,1, LONG_MIN,0);
+ TEST_BINOP(timespec_min, LONG_MIN,0, 0,-1, LONG_MIN,0);
+ TEST_BINOP(timespec_min, LONG_MIN,0, LONG_MAX,0, LONG_MIN,0);
+ TEST_BINOP(timespec_min, LONG_MIN,0, LONG_MIN,0, LONG_MIN,0);
+ TEST_BINOP(timespec_min, LONG_MAX,0, 0,1, 0,1);
+ TEST_BINOP(timespec_min, LONG_MAX,0, 0,-1, 0,-1);
+ TEST_BINOP(timespec_min, LONG_MAX,0, LONG_MAX,0, LONG_MAX,0);
+ TEST_BINOP(timespec_min, LONG_MAX,0, LONG_MIN,0, LONG_MIN,0);
+
+ // timespec_max
+
+ TEST_BINOP(timespec_max, 0,0, 0,0, 0,0);
+ TEST_BINOP(timespec_max, 0,0, 1,0, 1,0);
+ TEST_BINOP(timespec_max, 1,0, 0,0, 1,0);
+ TEST_BINOP(timespec_max, 1,0, 1,0, 1,0);
+ TEST_BINOP(timespec_max, 10,0, 1,0, 10,0);
+ TEST_BINOP(timespec_max, 10,0, 3,0, 10,0);
+ TEST_BINOP(timespec_max, 10,0, -3,0, 10,0);
+ TEST_BINOP(timespec_max, -10,0, 3,0, 3,0);
+ TEST_BINOP(timespec_max, -10,0, -3,0, -3,0);
+ TEST_BINOP(timespec_max, 10,0, 5,0, 10,0);
+ TEST_BINOP(timespec_max, 10,0, -5,0, 10,0);
+ TEST_BINOP(timespec_max, -10,0, 5,0, 5,0);
+ TEST_BINOP(timespec_max, -10,0, -5,0, -5,0);
+ TEST_BINOP(timespec_max, 1,500000000, 0,500000000, 1,500000000);
+ TEST_BINOP(timespec_max, 5,500000000, 2,999999999, 5,500000000);
+ TEST_BINOP(timespec_max, 0,500000000, 1,500000000, 1,500000000);
+ TEST_BINOP(timespec_max, 0,0, 1,500000000, 1,500000000);
+ TEST_BINOP(timespec_max, 1,0, 1,500000000, 1,500000000);
+ TEST_BINOP(timespec_max, 1,0, 0,1, 1,0);
+ TEST_BINOP(timespec_max, 1,123456789, 0,1000, 1,123456789);
+ TEST_BINOP(timespec_max, 1,0, 0,9999999, 1,0);
+ TEST_BINOP(timespec_max, 12345,54321, 0,100001, 12345,54321);
+ TEST_BINOP(timespec_max, LONG_MIN,0, 0,1, 0,1);
+ TEST_BINOP(timespec_max, LONG_MIN,0, 0,-1, 0,-1);
+ TEST_BINOP(timespec_max, LONG_MIN,0, LONG_MAX,0, LONG_MAX,0);
+ TEST_BINOP(timespec_max, LONG_MIN,0, LONG_MIN,0, LONG_MIN,0);
+ TEST_BINOP(timespec_max, LONG_MAX,0, 0,1, LONG_MAX,0);
+ TEST_BINOP(timespec_max, LONG_MAX,0, 0,-1, LONG_MAX,0);
+ TEST_BINOP(timespec_max, LONG_MAX,0, LONG_MAX,0, LONG_MAX,0);
+ TEST_BINOP(timespec_max, LONG_MAX,0, LONG_MIN,0, LONG_MAX,0);
+
+ // timespec_cmp
+
+ TEST_TEST_FUNC(timespec_cmp, 0,0, 0,0, 0);
+ TEST_TEST_FUNC(timespec_cmp, 100,0, 100,0, 0);
+ TEST_TEST_FUNC(timespec_cmp, -100,0, -100,0, 0);
+
+ TEST_TEST_FUNC(timespec_cmp, 1,0, 0,0, 1);
+ TEST_TEST_FUNC(timespec_cmp, 0,0, 1,0, -1);
+ TEST_TEST_FUNC(timespec_cmp, 0,1, 0,0, 1);
+ TEST_TEST_FUNC(timespec_cmp, 0,0, 0,1, -1);
+ TEST_TEST_FUNC(timespec_cmp, 1,0, 0,100, 1);
+ TEST_TEST_FUNC(timespec_cmp, 0,100 , 1,0, -1);
+
+ TEST_TEST_FUNC(timespec_cmp, -0,-0, 0,0, 0);
+ TEST_TEST_FUNC(timespec_cmp, -10,-500000000, -11,500000000, 0);
+ TEST_TEST_FUNC(timespec_cmp, -10,-500000001, -11,499999999, 0);
+ TEST_TEST_FUNC(timespec_cmp, -10,-500000001, -11,500000001, -1);
+ TEST_TEST_FUNC(timespec_cmp, -11,500000001, -10,-500000001, 1);
+
+ // timespec_eq
+
+ TEST_TEST_FUNC(timespec_eq, 0,0, 0,0, true);
+ TEST_TEST_FUNC(timespec_eq, 100,0, 100,0, true);
+ TEST_TEST_FUNC(timespec_eq, -200,0, -200,0, true);
+ TEST_TEST_FUNC(timespec_eq, 0,300, 0,300, true);
+ TEST_TEST_FUNC(timespec_eq, 0,-400, 0,-400, true);
+
+ TEST_TEST_FUNC(timespec_eq, 100,1, 100,0, false);
+ TEST_TEST_FUNC(timespec_eq, 101,0, 100,0, false);
+ TEST_TEST_FUNC(timespec_eq, -100,0, 100,0, false);
+ TEST_TEST_FUNC(timespec_eq, 0,10, 0,-10, false);
+
+ TEST_TEST_FUNC(timespec_eq, -0,-0, 0,0, true);
+ TEST_TEST_FUNC(timespec_eq, -10,-500000000, -11,500000000, true);
+ TEST_TEST_FUNC(timespec_eq, -10,-500000001, -11,499999999, true);
+ TEST_TEST_FUNC(timespec_eq, -10,-500000001, -11,500000001, false);
+
+ // timespec_gt
+
+ TEST_TEST_FUNC(timespec_gt, 1,0, 0,0, true);
+ TEST_TEST_FUNC(timespec_gt, 0,0, -1,0, true);
+ TEST_TEST_FUNC(timespec_gt, 0,1, 0,0, true);
+ TEST_TEST_FUNC(timespec_gt, 0,0, 0,-1, true);
+
+ TEST_TEST_FUNC(timespec_gt, 1,0, 1,0, false);
+ TEST_TEST_FUNC(timespec_gt, 1,1, 1,1, false);
+ TEST_TEST_FUNC(timespec_gt, -1,0, 0,0, false);
+ TEST_TEST_FUNC(timespec_gt, 0,-1, 0,0, false);
+
+ TEST_TEST_FUNC(timespec_gt, 0,0, -0,-0, false);
+ TEST_TEST_FUNC(timespec_gt, -10,-500000000, -11,500000000, false);
+ TEST_TEST_FUNC(timespec_gt, -11,500000000, -10,-500000000, false);
+ TEST_TEST_FUNC(timespec_gt, -10,-500000001, -11,499999999, false);
+ TEST_TEST_FUNC(timespec_gt, -11,499999999, -11,499999999, false);
+ TEST_TEST_FUNC(timespec_gt, -10,-500000001, -11,500000001, false);
+ TEST_TEST_FUNC(timespec_gt, -11,500000001, -10,-500000001, true);
+
+ // timespec_ge
+
+ TEST_TEST_FUNC(timespec_ge, 1,0, 0,0, true);
+ TEST_TEST_FUNC(timespec_ge, 0,0, -1,0, true);
+ TEST_TEST_FUNC(timespec_ge, 0,1, 0,0, true);
+ TEST_TEST_FUNC(timespec_ge, 0,0, 0,-1, true);
+ TEST_TEST_FUNC(timespec_ge, 1,0, 1,0, true);
+ TEST_TEST_FUNC(timespec_ge, 1,1, 1,1, true);
+
+ TEST_TEST_FUNC(timespec_ge, -1,0, 0,0, false);
+ TEST_TEST_FUNC(timespec_ge, 0,-1, 0,0, false);
+
+ TEST_TEST_FUNC(timespec_ge, 0,0, -0,-0, true);
+ TEST_TEST_FUNC(timespec_ge, -10,-500000000, -11,500000000, true);
+ TEST_TEST_FUNC(timespec_ge, -11,500000000, -10,-500000000, true);
+ TEST_TEST_FUNC(timespec_ge, -10,-500000001, -11,499999999, true);
+ TEST_TEST_FUNC(timespec_ge, -11,499999999, -11,499999999, true);
+ TEST_TEST_FUNC(timespec_ge, -10,-500000001, -11,500000001, false);
+ TEST_TEST_FUNC(timespec_ge, -11,500000001, -10,-500000001, true);
+
+ // timespec_lt
+
+ TEST_TEST_FUNC(timespec_lt, 0,0, 1,0, true);
+ TEST_TEST_FUNC(timespec_lt, -1,0, 0,0, true);
+ TEST_TEST_FUNC(timespec_lt, 0,0, 0,1, true);
+ TEST_TEST_FUNC(timespec_lt, 0,-1, 0,0, true);
+
+ TEST_TEST_FUNC(timespec_lt, 1,0, 1,0, false);
+ TEST_TEST_FUNC(timespec_lt, 1,1, 1,1, false);
+ TEST_TEST_FUNC(timespec_lt, 0,0, -1,0, false);
+ TEST_TEST_FUNC(timespec_lt, 0,0, 0,-1, false);
+
+ TEST_TEST_FUNC(timespec_lt, 0,0, -0,-0, false);
+ TEST_TEST_FUNC(timespec_lt, -10,-500000000, -11,500000000, false);
+ TEST_TEST_FUNC(timespec_lt, -11,500000000, -10,-500000000, false);
+ TEST_TEST_FUNC(timespec_lt, -10,-500000001, -11,499999999, false);
+ TEST_TEST_FUNC(timespec_lt, -11,499999999, -11,499999999, false);
+ TEST_TEST_FUNC(timespec_lt, -10,-500000001, -11,500000001, true);
+ TEST_TEST_FUNC(timespec_lt, -11,500000001, -10,-500000001, false);
+
+ // timespec_le
+
+ TEST_TEST_FUNC(timespec_le, 0,0, 1,0, true);
+ TEST_TEST_FUNC(timespec_le, -1,0, 0,0, true);
+ TEST_TEST_FUNC(timespec_le, 0,0, 0,1, true);
+ TEST_TEST_FUNC(timespec_le, 0,-1, 0,0, true);
+ TEST_TEST_FUNC(timespec_le, 1,0, 1,0, true);
+ TEST_TEST_FUNC(timespec_le, 1,1, 1,1, true);
+
+ TEST_TEST_FUNC(timespec_le, 0,0, -1,0, false);
+ TEST_TEST_FUNC(timespec_le, 0,0, 0,-1, false);
+
+ TEST_TEST_FUNC(timespec_le, 0,0, -0,-0, true);
+ TEST_TEST_FUNC(timespec_le, -10,-500000000, -11,500000000, true);
+ TEST_TEST_FUNC(timespec_le, -11,500000000, -10,-500000000, true);
+ TEST_TEST_FUNC(timespec_le, -10,-500000001, -11,499999999, true);
+ TEST_TEST_FUNC(timespec_le, -11,499999999, -11,499999999, true);
+ TEST_TEST_FUNC(timespec_le, -10,-500000001, -11,500000001, true);
+ TEST_TEST_FUNC(timespec_le, -11,500000001, -10,-500000001, false);
+
+ // timespec_from_double
+
+ TEST_FROM_DOUBLE(0.0, 0,0);
+ TEST_FROM_DOUBLE(10.0, 10,0);
+ TEST_FROM_DOUBLE(-10.0, -10,0);
+ TEST_FROM_DOUBLE(0.5, 0,500000000);
+ TEST_FROM_DOUBLE(-0.5, -1,500000000);
+ TEST_FROM_DOUBLE(10.5, 10,500000000);
+ TEST_FROM_DOUBLE(-10.5, -11,500000000);
+
+ // timespec_to_double
+
+ TEST_TO_DOUBLE(0,0, 0.0);
+ TEST_TO_DOUBLE(10,0, 10.0);
+ TEST_TO_DOUBLE(-10,0, -10.0);
+ TEST_TO_DOUBLE(0,500000000, 0.5);
+ TEST_TO_DOUBLE(0,-500000000, -0.5);
+ TEST_TO_DOUBLE(10,500000000, 10.5);
+ TEST_TO_DOUBLE(10,-500000000, 9.5);
+ TEST_TO_DOUBLE(-10,500000000, -9.5);
+ TEST_TO_DOUBLE(-10,-500000000, -10.5);
+
+ // timespec_from_timeval
+
+ TEST_FROM_TIMEVAL(0,0, 0,0);
+ TEST_FROM_TIMEVAL(1,0, 1,0);
+ TEST_FROM_TIMEVAL(1000,0, 1000,0);
+ TEST_FROM_TIMEVAL(0,0, 0,0);
+ TEST_FROM_TIMEVAL(-1,0, -1,0);
+ TEST_FROM_TIMEVAL(-1000,0, -1000,0);
+
+ TEST_FROM_TIMEVAL(1,1, 1,1000);
+ TEST_FROM_TIMEVAL(1,1000, 1,1000000);
+ TEST_FROM_TIMEVAL(1,-1, 0,999999000);
+ TEST_FROM_TIMEVAL(1,-1000, 0,999000000);
+ TEST_FROM_TIMEVAL(-1,-1, -2,999999000);
+ TEST_FROM_TIMEVAL(-1,-1000, -2,999000000);
+
+ // timespec_to_timeval
+
+ TEST_TO_TIMEVAL(0,0, 0,0);
+ TEST_TO_TIMEVAL(1,0, 1,0);
+ TEST_TO_TIMEVAL(10,0, 10,0);
+ TEST_TO_TIMEVAL(-1,0, -1,0);
+ TEST_TO_TIMEVAL(-10,0, -10,0);
+
+ TEST_TO_TIMEVAL(1,1, 1,0);
+ TEST_TO_TIMEVAL(1,999, 1,0);
+ TEST_TO_TIMEVAL(1,1000, 1,1);
+ TEST_TO_TIMEVAL(1,1001, 1,1);
+ TEST_TO_TIMEVAL(1,2000, 1,2);
+ TEST_TO_TIMEVAL(1,2000000, 1,2000);
+
+ TEST_TO_TIMEVAL(1,-1, 0,999999);
+ TEST_TO_TIMEVAL(1,-999, 0,999999);
+ TEST_TO_TIMEVAL(1,-1000, 0,999999);
+ TEST_TO_TIMEVAL(1,-1001, 0,999998);
+ TEST_TO_TIMEVAL(1,-2000, 0,999998);
+ TEST_TO_TIMEVAL(1,-2000000, 0,998000);
+
+ TEST_TO_TIMEVAL(-1,-1, -2,999999);
+ TEST_TO_TIMEVAL(-1,-999, -2,999999);
+ TEST_TO_TIMEVAL(-1,-1000, -2,999999);
+ TEST_TO_TIMEVAL(-1,-1001, -2,999998);
+ TEST_TO_TIMEVAL(-1,-2000, -2,999998);
+ TEST_TO_TIMEVAL(-1,-2000000, -2,998000);
+
+ TEST_TO_TIMEVAL(1,1500000000, 2,500000);
+ TEST_TO_TIMEVAL(1,-1500000000, -1,500000);
+ TEST_TO_TIMEVAL(-1,-1500000000, -3,500000);
+
+ // timespec_from_ms
+
+ TEST_FROM_MS(0, 0,0);
+ TEST_FROM_MS(1, 0,1000000);
+ TEST_FROM_MS(-1, -1,999000000);
+ TEST_FROM_MS(1500, 1,500000000);
+ TEST_FROM_MS(-1000, -1,0);
+ TEST_FROM_MS(-1500, -2,500000000);
+
+ // timespec_to_ms
+
+ TEST_TO_MS(0,0, 0);
+ TEST_TO_MS(10,0, 10000);
+ TEST_TO_MS(-10,0, -10000);
+ TEST_TO_MS(0,500000000, 500);
+ TEST_TO_MS(0,-500000000, -500);
+ TEST_TO_MS(10,500000000, 10500);
+ TEST_TO_MS(10,-500000000, 9500);
+ TEST_TO_MS(-10,500000000, -9500);
+ TEST_TO_MS(-10,-500000000, -10500);
+
+ // timespec_normalise
+
+ TEST_NORMALISE(0,0, 0,0);
+
+ TEST_NORMALISE(0,1000000000, 1,0);
+ TEST_NORMALISE(0,1500000000, 1,500000000);
+ TEST_NORMALISE(0,-1000000000, -1,0);
+ TEST_NORMALISE(0,-1500000000, -2,500000000);
+
+ TEST_NORMALISE(5,1000000000, 6,0);
+ TEST_NORMALISE(5,1500000000, 6,500000000);
+ TEST_NORMALISE(-5,-1000000000, -6,0);
+ TEST_NORMALISE(-5,-1500000000, -7,500000000);
+
+ TEST_NORMALISE(0,2000000000, 2,0);
+ TEST_NORMALISE(0,2100000000, 2,100000000);
+ TEST_NORMALISE(0,-2000000000, -2,0);
+ TEST_NORMALISE(0,-2100000000, -3,900000000);
+
+ TEST_NORMALISE(1,-500000001, 0,499999999);
+ TEST_NORMALISE(1,-500000000, 0,500000000);
+ TEST_NORMALISE(1,-499999999, 0,500000001);
+ TEST_NORMALISE(0,-499999999, -1,500000001);
+
+ TEST_NORMALISE(-1,500000000, -1,500000000);
+ TEST_NORMALISE(-1,499999999, -1,499999999);
+
+ if(result > 0)
+ {
+ printf("%d tests failed\n", result);
+ }
+ else{
+ printf("All tests passed\n");
+ }
+
+ return !!result; /* Don't overflow the exit status */
+}
+#endif
diff --git a/src/lib/core/utils.c b/src/lib/core/utils.c
index 62f3bec..a8b1c73 100644
--- a/src/lib/core/utils.c
+++ b/src/lib/core/utils.c
@@ -1078,3 +1078,44 @@ int check_python_package_dependencies(const char *srcdir) {
}
return 0;
}
+
+int str_to_timeout(char *s) {
+ if (!s) {
+ return 0; // no timeout
+ }
+
+ char *scale = NULL;
+ int value = (int) strtol(s, &scale, 10);
+ if (scale) {
+ if (*scale == 's') {
+ value *= 1; // seconds, no-op
+ } else if (*scale == 'm') {
+ value *= 60; // minutes
+ } else if (*scale == 'h') {
+ value *= 3200; // hours
+ } else {
+ return STR_TO_TIMEOUT_INVALID_TIME_SCALE; // invalid time scale
+ }
+ }
+
+ if (value < 0) {
+ return STR_TO_TIMEOUT_NEGATIVE; // cannot be negative
+ }
+ return value;
+}
+
+void seconds_to_human_readable(const int v, char *result, const size_t maxlen) {
+ const int hours = v / 3600;
+ const int minutes = (v % 3600) / 60;
+ const int seconds = v % 60;
+
+ memset(result, '\0', maxlen);
+ if (hours) {
+ snprintf(result + strlen(result), maxlen, "%dh ", hours);
+ }
+ if (hours || minutes) {
+ snprintf(result + strlen(result), maxlen, "%dm ", minutes);
+ }
+ snprintf(result + strlen(result), maxlen, "%ds", seconds);
+}
+
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 2b09e9e..08ef833 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -30,6 +30,9 @@ foreach(source_file ${source_files})
elseif (CMAKE_C_COMPILER_ID STREQUAL "MSVC")
target_compile_options(${test_executable} PRIVATE ${win_cflags} ${win_msvc_cflags})
endif()
+ if (TESTS_VERBOSE)
+ target_compile_definitions(${test_executable} PRIVATE STASIS_TEST_VERBOSE=1)
+ endif ()
target_include_directories(${test_executable} PRIVATE
${core_INCLUDE}
${delivery_INCLUDE}
diff --git a/tests/include/testing.h b/tests/include/testing.h
index ab24115..6fa5ca6 100644
--- a/tests/include/testing.h
+++ b/tests/include/testing.h
@@ -9,6 +9,15 @@
#define __FILE_NAME__ __FILE__
#endif
+#ifdef STASIS_TEST_VERBOSE
+#define STASIS_TEST_MSG(MSG, ...) do { \
+fprintf(stderr, "%s:%d:%s(): ", path_basename(__FILE__), __LINE__, __FUNCTION__); \
+fprintf(stderr, MSG LINE_SEP, __VA_ARGS__); \
+} while (0)
+#else
+#define STASIS_TEST_MSG(MSG, ...) do {} while (0)
+#endif
+
typedef void(STASIS_TEST_FUNC)();
struct stasis_test_result_t {
const char *filename;
diff --git a/tests/test_multiprocessing.c b/tests/test_multiprocessing.c
index 7c9d695..3a462f1 100644
--- a/tests/test_multiprocessing.c
+++ b/tests/test_multiprocessing.c
@@ -161,7 +161,7 @@ void test_mp_fail_fast() {
if (task->status == 0) result.total_status_success++;
if (task->pid == MP_POOL_PID_UNUSED && task->status == MP_POOL_TASK_STATUS_INITIAL) result.total_unused++;
}
- fprintf(stderr, "total_status_fail = %d\ntotal_status_success = %d\ntotal_signaled = %d\ntotal_unused = %d\n",
+ STASIS_TEST_MSG("\ntotal_status_fail = %d\ntotal_status_success = %d\ntotal_signaled = %d\ntotal_unused = %d",
result.total_status_fail, result.total_status_success, result.total_signaled, result.total_unused);
STASIS_ASSERT(result.total_status_fail, "Should have failures");
STASIS_ASSERT(result.total_status_success, "Should have successes");
@@ -171,6 +171,43 @@ void test_mp_fail_fast() {
mp_pool_free(&p);
}
+static void test_mp_timeout() {
+ struct MultiProcessingPool *p = NULL;
+ p = mp_pool_init("timeout", "timeoutlogs");
+ p->status_interval = 1;
+ struct MultiProcessingTask *task = mp_pool_task(p, "timeout", NULL, "sleep 5");
+ int timeout = 3;
+ task->timeout = timeout;
+ mp_pool_join(p, 1, 0);
+ STASIS_ASSERT((task->time_data.duration >= (double) timeout && task->time_data.duration < (double) timeout + 1), "Timeout occurred out of desired range");
+ mp_pool_show_summary(p);
+ mp_pool_free(&p);
+}
+
+static void test_mp_seconds_to_human_readable() {
+ const struct testcase {
+ int seconds;
+ const char *expected;
+ } tc[] = {
+ {.seconds = -1, "-1s"},
+ {.seconds = 0, "0s"},
+ {.seconds = 10, "10s"},
+ {.seconds = 20, "20s"},
+ {.seconds = 30, "30s"},
+ {.seconds = 60, "1m 0s"},
+ {.seconds = 125, "2m 5s"},
+ {.seconds = 3600, "1h 0m 0s"},
+ {.seconds = 86399, "23h 59m 59s"},
+ {.seconds = 86400, "24h 0m 0s"},
+ };
+ for (size_t i = 0; i < sizeof(tc) / sizeof(tc[0]); i++) {
+ char result[255] = {0};
+ seconds_to_human_readable(tc[i].seconds, result, sizeof(result));
+ STASIS_TEST_MSG("seconds=%d, expected: %s, got: %s", tc[i].seconds, tc[i].expected, result);
+ STASIS_ASSERT(strcmp(result, tc[i].expected) == 0, "bad output");
+ }
+}
+
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void *pool_container(void *data) {
char *commands_sc[] = {
@@ -212,8 +249,13 @@ int main(int argc, char *argv[]) {
test_mp_pool_free,
test_mp_pool_workflow,
test_mp_fail_fast,
+ test_mp_timeout,
+ test_mp_seconds_to_human_readable,
test_mp_stop_continue
};
+
+ globals.task_timeout = 60;
+
STASIS_TEST_RUN(tests);
STASIS_TEST_END_MAIN();
}
generated by cgit (git 2.34.1) at 2026-01-18 12:12:04 -0500