/*
* stress_rdrand()
* stress Intel rdrand instruction
*/
static int stress_rdrand(const args_t *args)
{
if (rdrand_supported) {
double time_start, duration, billion_bits;
bool lock = false;
time_start = time_now();
do {
#if defined(__x86_64__) || defined(__x86_64)
RDRAND64x32();
#else
RDRAND32x64();
#endif
inc_counter(args);
} while (keep_stressing());
duration = time_now() - time_start;
billion_bits = ((double)get_counter(args) * 64.0 * 32.0) / 1000000000.0;
pr_lock(&lock);
pr_dbg_lock(&lock, "%s: %.3f billion random bits read "
"(instance %" PRIu32")\n",
args->name, billion_bits, args->instance);
if (duration > 0.0) {
pr_dbg_lock(&lock, "%s: %.3f billion random bits per "
"second (instance %" PRIu32")\n",
args->name,
(double)billion_bits / duration,
args->instance);
}
pr_unlock(&lock);
}
return EXIT_SUCCESS;
}
/*
* semaphore_posix_thrash()
* exercise the semaphore
*/
static void *semaphore_posix_thrash(void *arg)
{
const pthread_args_t *p_args = arg;
const args_t *args = p_args->args;
static void *nowt = NULL;
do {
int i;
for (i = 0; g_keep_stressing_flag && i < 1000; i++) {
if (sem_trywait(&sem) < 0) {
if (errno == 0 || errno == EAGAIN)
continue;
if (errno != EINTR)
pr_fail_dbg("sem_trywait");
break;
}
inc_counter(args);
if (sem_post(&sem) < 0) {
pr_fail_dbg("sem_post");
break;
}
if (i & 1)
(void)shim_sched_yield();
else
(void)shim_usleep(0);
}
} while (keep_stressing());
return &nowt;
}
/*!
* \brief Wrappers for complex double-precision egblas apxdbpy_3 operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void apxdbpy_3(size_t n,
etl::complex<double> alpha,
etl::complex<double>* A,
size_t lda,
etl::complex<double> beta,
etl::complex<double>* B,
size_t ldb,
etl::complex<double>* C,
size_t ldc) {
#ifdef EGBLAS_HAS_ZAPXDBPY_3
inc_counter("egblas");
egblas_zapxdbpy_3(n, complex_cast(alpha), reinterpret_cast<cuDoubleComplex*>(A), lda, complex_cast(beta), reinterpret_cast<cuDoubleComplex*>(B), ldb,
reinterpret_cast<cuDoubleComplex*>(C), ldc);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(beta);
cpp_unused(B);
cpp_unused(ldb);
cpp_unused(C);
cpp_unused(ldc);
cpp_unreachable("Invalid call to egblas::apxdbpy_3");
#endif
}
static void
locking_slave(int in_fd, int out_fd)
{
char cmd;
int rv;
file_lock *lock = file_lock_new(TEST_FILENAME);
gboolean locked = 0;
while (1) {
if (!pipeget(in_fd, &cmd))
cmd = 'q';
switch (cmd) {
case 'q': /* q = quit */
tu_dbg("slave: quitting\n");
file_lock_free(lock);
lock = NULL;
return;
case 'l': /* l = try locking; reply with 'y' or 'n' */
g_assert(!locked);
rv = file_lock_lock(lock);
if (rv == -1) {
g_fprintf(stderr, "file_lock_lock: %s\n",
strerror(errno));
return;
}
tu_dbg("slave: lock attempt => %s\n", (rv == 1)? "n" : "y");
pipeput(out_fd, (rv == 1)? "n" : "y");
if (rv != 1)
locked = 1;
break;
case 'i': /* i = increment counter, reply with new value */
g_assert(locked);
if (!inc_counter(lock))
return;
tu_dbg("slave: inc'd to %c\n", lock->data[0]);
pipeput(out_fd, lock->data);
break;
case 'u': /* u = try unlocking; reply with 'k' */
g_assert(locked);
rv = file_lock_unlock(lock);
if (rv != 0) {
g_fprintf(stderr, "file_lock_unlock: %s\n",
strerror(errno));
return;
}
tu_dbg("slave: unlocked\n");
pipeput(out_fd, "k");
locked = 0;
break;
default:
return;
}
}
}
/*
* stress_sigq
* stress by heavy sigqueue message sending
*/
static int stress_sigq(const args_t *args)
{
pid_t pid;
if (stress_sighandler(args->name, SIGUSR1, stress_sigqhandler, NULL) < 0)
return EXIT_FAILURE;
again:
pid = fork();
if (pid < 0) {
if (g_keep_stressing_flag && (errno == EAGAIN))
goto again;
pr_fail_dbg("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
sigset_t mask;
(void)setpgid(0, g_pgrp);
stress_parent_died_alarm();
(void)sigemptyset(&mask);
(void)sigaddset(&mask, SIGUSR1);
while (g_keep_stressing_flag) {
siginfo_t info;
if (sigwaitinfo(&mask, &info) < 0)
break;
if (info.si_value.sival_int)
break;
}
pr_dbg("%s: child got termination notice\n", args->name);
pr_dbg("%s: exited on pid [%d] (instance %" PRIu32 ")\n",
args->name, (int)getpid(), args->instance);
_exit(0);
} else {
/* Parent */
union sigval s;
int status;
do {
(void)memset(&s, 0, sizeof(s));
s.sival_int = 0;
(void)sigqueue(pid, SIGUSR1, s);
inc_counter(args);
} while (keep_stressing());
pr_dbg("%s: parent sent termination notice\n", args->name);
(void)memset(&s, 0, sizeof(s));
s.sival_int = 1;
(void)sigqueue(pid, SIGUSR1, s);
(void)shim_usleep(250);
/* And ensure child is really dead */
(void)kill(pid, SIGKILL);
(void)shim_waitpid(pid, &status, 0);
}
return EXIT_SUCCESS;
}
/*
* stress_splice
* stress copying of /dev/zero to /dev/null
*/
static int stress_splice(const args_t *args)
{
int fd_in, fd_out, fds[2];
size_t splice_bytes = DEFAULT_SPLICE_BYTES;
if (!get_setting("splice-bytes", &splice_bytes)) {
if (g_opt_flags & OPT_FLAGS_MAXIMIZE)
splice_bytes = MAX_SPLICE_BYTES;
if (g_opt_flags & OPT_FLAGS_MINIMIZE)
splice_bytes = MIN_SPLICE_BYTES;
}
splice_bytes /= args->num_instances;
if (splice_bytes < MIN_SPLICE_BYTES)
splice_bytes = MIN_SPLICE_BYTES;
if (pipe(fds) < 0) {
pr_fail_err("pipe");
return EXIT_FAILURE;
}
if ((fd_in = open("/dev/zero", O_RDONLY)) < 0) {
(void)close(fds[0]);
(void)close(fds[1]);
pr_fail_err("open");
return EXIT_FAILURE;
}
if ((fd_out = open("/dev/null", O_WRONLY)) < 0) {
(void)close(fd_in);
(void)close(fds[0]);
(void)close(fds[1]);
pr_fail_err("open");
return EXIT_FAILURE;
}
do {
ssize_t ret;
ret = splice(fd_in, NULL, fds[1], NULL,
splice_bytes, SPLICE_F_MOVE);
if (ret < 0)
break;
ret = splice(fds[0], NULL, fd_out, NULL,
splice_bytes, SPLICE_F_MOVE);
if (ret < 0)
break;
inc_counter(args);
} while (keep_stressing());
(void)close(fd_out);
(void)close(fd_in);
(void)close(fds[0]);
(void)close(fds[1]);
return EXIT_SUCCESS;
}
/*
* stress_lsearch()
* stress lsearch
*/
static int stress_lsearch(const args_t *args)
{
int32_t *data, *root;
size_t i, max;
uint64_t lsearch_size = DEFAULT_LSEARCH_SIZE;
if (!get_setting("lsearch-size", &lsearch_size)) {
if (g_opt_flags & OPT_FLAGS_MAXIMIZE)
lsearch_size = MAX_LSEARCH_SIZE;
if (g_opt_flags & OPT_FLAGS_MINIMIZE)
lsearch_size = MIN_LSEARCH_SIZE;
}
max = (size_t)lsearch_size;
if ((data = calloc(max, sizeof(*data))) == NULL) {
pr_fail_dbg("malloc");
return EXIT_NO_RESOURCE;
}
if ((root = calloc(max, sizeof(*data))) == NULL) {
free(data);
pr_fail_dbg("malloc");
return EXIT_NO_RESOURCE;
}
do {
size_t n = 0;
/* Step #1, populate with data */
for (i = 0; g_keep_stressing_flag && i < max; i++) {
void *ptr;
data[i] = ((mwc32() & 0xfff) << 20) ^ i;
ptr = lsearch(&data[i], root, &n, sizeof(*data), cmp);
(void)ptr;
}
/* Step #2, find */
for (i = 0; g_keep_stressing_flag && i < n; i++) {
int32_t *result;
result = lfind(&data[i], root, &n, sizeof(*data), cmp);
if (g_opt_flags & OPT_FLAGS_VERIFY) {
if (result == NULL)
pr_fail("%s: element %zu could not be found\n", args->name, i);
else if (*result != data[i])
pr_fail("%s: element %zu found %" PRIu32 ", expecting %" PRIu32 "\n",
args->name, i, *result, data[i]);
}
}
inc_counter(args);
} while (keep_stressing());
free(root);
free(data);
return EXIT_SUCCESS;
}
int main(void) {
unsigned char counter[COUNTERSIZE];
int i;
InitializeCounter(counter, 0xff);
for (i = 0; i < 0xffff; i++) {
asm("sim-clearcycles");
inc_counter(counter);
asm("sim-printcycles");
}
return 0;
}
/*!
* \brief Wrappers for complex double-precision egblas real operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void real(size_t n, double alpha, std::complex<double>* A, size_t lda, double* B, size_t ldb) {
#ifdef EGBLAS_HAS_ZREAL
inc_counter("egblas");
egblas_zreal(n, alpha, reinterpret_cast<cuDoubleComplex*>(A), lda, (B), ldb);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(B);
cpp_unused(ldb);
cpp_unreachable("Invalid call to egblas::real");
#endif
}
/*!
* \brief Wrappers for complex double-precision egblas sqrt operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void sqrt(size_t n, etl::complex<double> alpha, etl::complex<double>* A, size_t lda, etl::complex<double>* B, size_t ldb) {
#ifdef EGBLAS_HAS_ZSQRT
inc_counter("egblas");
egblas_zsqrt(n, complex_cast(alpha), reinterpret_cast<cuDoubleComplex*>(A), lda, reinterpret_cast<cuDoubleComplex*>(B), ldb);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(B);
cpp_unused(ldb);
cpp_unreachable("Invalid call to egblas::sqrt");
#endif
}
/*!
* \brief Wrappers for double-precision egblas sqrt operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void sqrt(size_t n, double alpha, double* A, size_t lda, double* B, size_t ldb) {
#ifdef EGBLAS_HAS_DSQRT
inc_counter("egblas");
egblas_dsqrt(n, alpha, A, lda, B, ldb);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(B);
cpp_unused(ldb);
cpp_unreachable("Invalid call to egblas::sqrt");
#endif
}
/*!
* \brief Wrappers for complex single-precision egblas real operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void real(size_t n, float alpha, etl::complex<float>* A, size_t lda, float* B, size_t ldb) {
#ifdef EGBLAS_HAS_CREAL
inc_counter("egblas");
egblas_creal(n, alpha, reinterpret_cast<cuComplex*>(A), lda, (B), ldb);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(B);
cpp_unused(ldb);
cpp_unreachable("Invalid call to egblas::real");
#endif
}
/*!
* \brief Wrappers for complex single-precision egblas min operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void min(size_t n, etl::complex<float> alpha, etl::complex<float>* A, size_t lda, etl::complex<float>* B, size_t ldb) {
#ifdef EGBLAS_HAS_CMIN
inc_counter("egblas");
egblas_cmin(n, complex_cast(alpha), reinterpret_cast<cuComplex*>(A), lda, reinterpret_cast<cuComplex*>(B), ldb);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(B);
cpp_unused(ldb);
cpp_unreachable("Invalid call to egblas::min");
#endif
}
/*!
* \brief Wrappers for complex double-precision egblas not_equal operation
* \param n The size of the vector
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
* \param C The memory of the vector c
* \param ldc The leading dimension of c
*/
inline void not_equal(size_t n, const etl::complex<double>* A, size_t lda, const etl::complex<double>* B, size_t ldb, bool* C, size_t ldc) {
#ifdef EGBLAS_HAS_ZNOT_EQUAL
inc_counter("egblas");
egblas_znot_equal(n, reinterpret_cast<const cuDoubleComplex*>(A), lda, reinterpret_cast<const cuDoubleComplex*>(B), ldb, C, ldc);
#else
cpp_unused(n);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(B);
cpp_unused(ldb);
cpp_unused(C);
cpp_unused(ldc);
cpp_unreachable("Invalid call to egblas::not_equal");
#endif
}
/*!
* \brief Wrappers for double-precision egblas not_equal operation
* \param n The size of the vector
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
* \param C The memory of the vector c
* \param ldc The leading dimension of c
*/
inline void not_equal(size_t n, const double* A, size_t lda, const double* B, size_t ldb, bool* C, size_t ldc) {
#ifdef EGBLAS_HAS_DNOT_EQUAL
inc_counter("egblas");
egblas_dnot_equal(n, A, lda, B, ldb, C, ldc);
#else
cpp_unused(n);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(B);
cpp_unused(ldb);
cpp_unused(C);
cpp_unused(ldc);
cpp_unreachable("Invalid call to egblas::not_equal");
#endif
}
/*!
* \brief Wrappers for double-precision egblas axpby operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void axpby(size_t n, double alpha, double* A, size_t lda, double beta, double* B, size_t ldb) {
#ifdef EGBLAS_HAS_DAXPBY
inc_counter("egblas");
egblas_daxpby(n, alpha, A, lda, beta, B, ldb);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(beta);
cpp_unused(B);
cpp_unused(ldb);
cpp_unreachable("Invalid call to egblas::axpby");
#endif
}
/*!
* \brief Wrappers for complex double-precision egblas axpby operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void axpby(size_t n, etl::complex<double> alpha, etl::complex<double>* A, size_t lda, std::complex<double> beta, etl::complex<double>* B, size_t ldb) {
#ifdef EGBLAS_HAS_ZAXPBY
inc_counter("egblas");
egblas_zaxpby(n, complex_cast(alpha), reinterpret_cast<cuDoubleComplex*>(A), lda, complex_cast(beta), reinterpret_cast<cuDoubleComplex*>(B), ldb);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(beta);
cpp_unused(B);
cpp_unused(ldb);
cpp_unreachable("Invalid call to egblas::axpby");
#endif
}
/*!
* \brief Wrappers for double-precision egblas min operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void min(size_t n, double alpha, double* A, size_t lda, double* B, size_t ldb, double* C, size_t ldc) {
#ifdef EGBLAS_HAS_DMIN3
inc_counter("egblas");
egblas_dmin(n, alpha, A, lda, B, ldb, C, ldc);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(B);
cpp_unused(ldb);
cpp_unused(C);
cpp_unused(ldc);
cpp_unreachable("Invalid call to egblas::min");
#endif
}
/*
* stress_memthrash_func()
* pthread that exits immediately
*/
static void *stress_memthrash_func(void *arg)
{
uint8_t stack[SIGSTKSZ + STACK_ALIGNMENT];
static void *nowt = NULL;
const pthread_args_t *parg = (pthread_args_t *)arg;
const args_t *args = parg->args;
const memthrash_func_t func = (memthrash_func_t)parg->data;
/*
* Block all signals, let controlling thread
* handle these
*/
(void)sigprocmask(SIG_BLOCK, &set, NULL);
/*
* According to POSIX.1 a thread should have
* a distinct alternative signal stack.
* However, we block signals in this thread
* so this is probably just totally unncessary.
*/
(void)memset(stack, 0, sizeof(stack));
if (stress_sigaltstack(stack, SIGSTKSZ) < 0)
goto die;
while (!thread_terminate && keep_stressing()) {
size_t j;
for (j = MATRIX_SIZE_MIN_SHIFT; j <= MATRIX_SIZE_MAX_SHIFT &&
keep_stressing(); j++) {
size_t mem_size = 1 << (2 * j);
size_t i;
for (i = 0; i < SIZEOF_ARRAY(memthrash_methods); i++)
if (func == memthrash_methods[i].func)
break;
func(args, mem_size);
inc_counter(args);
}
}
/* Wait parent up, all done! */
(void)kill(args->pid, SIGALRM);
die:
return &nowt;
}
void gen_perms(double_string *ds, int qty, int size) {
counter *c = make_counter(qty, size);
int i = 0;
for(;;) {
double_string *tmp = dup_double_string(ds);
for(i = 0; i < qty; i++) {
double v = get_double_string(&tmp, c->values[i]);
printf("%.2f ", v);
}
printf("\n");
destroy_double_string(tmp);
if(inc_counter(c)) {
break;
}
}
free(c);
}
END_DEF
SIGHANDLER(_tmr0_handler)
{
inc_counter();
// Check the brightness knob and update the pwm
ADCON0bits.GO = 1;
while (ADCON0bits.GO);
CCPR1L = ADRESH;
// Add to the random "pool"
rand_seed ^= ADRESH;
// Re-enable ourselves.
INTCONbits.T0IF = 0;
}
/* Reseed the generator based on hopefully non-guessable input. */
static void
generator_reseed(struct fortuna_state *st, const unsigned char *data,
size_t len)
{
SHA256_CTX ctx;
/* Calculate SHA[d]-256(key||s) and make that the new key. Depend on the
* SHA-256 hash size being the AES-256 key size. */
shad256_init(&ctx);
shad256_update(&ctx, st->key, AES256_KEYSIZE);
shad256_update(&ctx, data, len);
shad256_result(&ctx, st->key);
zap(&ctx, sizeof(ctx));
krb5int_aes_enc_key(st->key, AES256_KEYSIZE, &st->ciph);
/* Increment counter. */
inc_counter(st);
}
/*!
* \brief Wrappers for double-precision egblas apxdbpy_3 operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void apxdbpy_3(size_t n, double alpha, double* A, size_t lda, double beta, double* B, size_t ldb, double* C, size_t ldc) {
#ifdef EGBLAS_HAS_DAPXDBPY_3
inc_counter("egblas");
egblas_dapxdbpy_3(n, alpha, A, lda, beta, B, ldb, C, ldc);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(beta);
cpp_unused(B);
cpp_unused(ldb);
cpp_unused(C);
cpp_unused(ldc);
cpp_unreachable("Invalid call to egblas::apxdbpy_3");
#endif
}
/*!
* \brief Wrappers for complex double-precision egblas min operation
* \param n The size of the vector
* \param alpha The scaling factor alpha
* \param A The memory of the vector a
* \param lda The leading dimension of a
* \param B The memory of the vector b
* \param ldb The leading dimension of b
*/
inline void min(
size_t n, etl::complex<double> alpha, etl::complex<double>* A, size_t lda, etl::complex<double>* B, size_t ldb, etl::complex<double>* C, size_t ldc) {
#ifdef EGBLAS_HAS_ZMIN3
inc_counter("egblas");
egblas_zmin(n, complex_cast(alpha), reinterpret_cast<cuDoubleComplex*>(A), lda, reinterpret_cast<cuDoubleComplex*>(B), ldb,
reinterpret_cast<cuDoubleComplex*>(C), ldc);
#else
cpp_unused(n);
cpp_unused(alpha);
cpp_unused(A);
cpp_unused(lda);
cpp_unused(B);
cpp_unused(ldb);
cpp_unused(C);
cpp_unused(ldc);
cpp_unreachable("Invalid call to egblas::min");
#endif
}
/*
* stress on sync()
* stress system by IO sync calls
*/
static int stress_io(const args_t *args)
{
#if defined(HAVE_SYNCFS)
int i, fd, n_mnts;
char *mnts[MAX_MNTS];
int fds[MAX_MNTS];
n_mnts = mount_get(mnts, MAX_MNTS);
for (i = 0; i < n_mnts; i++)
fds[i] = openat(AT_FDCWD, mnts[i], O_RDONLY | O_NONBLOCK | O_DIRECTORY);
fd = openat(AT_FDCWD, ".", O_RDONLY | O_NONBLOCK | O_DIRECTORY);
#endif
do {
(void)sync();
#if defined(HAVE_SYNCFS)
if ((fd != -1) && (syncfs(fd) < 0))
pr_fail_err("syncfs");
/* try to sync on all the mount points */
for (i = 0; i < n_mnts; i++)
if (fds[i] != -1)
(void)syncfs(fds[i]);
#endif
inc_counter(args);
} while (keep_stressing());
#if defined(HAVE_SYNCFS)
if (fd != -1)
(void)close(fd);
for (i = 0; i < n_mnts; i++)
if (fds[i] != -1)
(void)close(fds[i]);
mount_free(mnts, n_mnts);
#endif
return EXIT_SUCCESS;
}
long LCS::read() {
// wait for the chip to become ready
while (!is_ready());
byte data1[3];
byte data2[3];
byte data3[3];
// pulse the clock pin 24 times to read the data
for (byte j = 3; j--;) {
for (char i = 8; i--;) {
digitalWrite(PD_SCK, HIGH);
bitWrite(data1[j], i, digitalRead(DOUT1)); //@@@@@@@@@@@@@@@@@ I feel like this might pose a problem if 3 bitWrites takes too long @@@@@@@@@@@@@@@@
bitWrite(data2[j], i, digitalRead(DOUT2));
bitWrite(data3[j], i, digitalRead(DOUT3));
digitalWrite(PD_SCK, LOW);
}
}
// set the channel and the gain factor for the next reading using the clock pin
for (int i = 0; i < GAIN; i++) {
digitalWrite(PD_SCK, HIGH);
digitalWrite(PD_SCK, LOW);
}
data1[2] ^= 0x80;
data2[2] ^= 0x80;
data3[2] ^= 0x80;
long result1 = ((uint32_t) data1[2] << 16) | ((uint32_t) data1[1] << 8) | (uint32_t) data1[0];
long result2 = ((uint32_t) data2[2] << 16) | ((uint32_t) data2[1] << 8) | (uint32_t) data2[0];
long result3 = ((uint32_t) data3[2] << 16) | ((uint32_t) data3[1] << 8) | (uint32_t) data3[0];
long total = (long)((double)result3/1)+ (long)((double)result2*1) + result1;//(long) ((double)result1/1.045);
//long total = result3;
BVAL[COUNTER] = total;
inc_counter();
return total;
}
/*
* stress_tlb_shootdown()
* stress out TLB shootdowns
*/
static int stress_tlb_shootdown(const args_t *args)
{
const size_t page_size = args->page_size;
const size_t mmap_size = page_size * MMAP_PAGES;
pid_t pids[MAX_TLB_PROCS];
cpu_set_t proc_mask_initial;
if (sched_getaffinity(0, sizeof(proc_mask_initial), &proc_mask_initial) < 0) {
pr_fail_err("could not get CPU affinity");
return EXIT_FAILURE;
}
do {
uint8_t *mem, *ptr;
int retry = 128;
cpu_set_t proc_mask;
int32_t tlb_procs, i;
const int32_t max_cpus = stress_get_processors_configured();
CPU_ZERO(&proc_mask);
CPU_OR(&proc_mask, &proc_mask_initial, &proc_mask);
tlb_procs = max_cpus;
if (tlb_procs > MAX_TLB_PROCS)
tlb_procs = MAX_TLB_PROCS;
if (tlb_procs < MIN_TLB_PROCS)
tlb_procs = MIN_TLB_PROCS;
for (;;) {
mem = mmap(NULL, mmap_size, PROT_WRITE | PROT_READ,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if ((void *)mem == MAP_FAILED) {
if ((errno == EAGAIN) ||
(errno == ENOMEM) ||
(errno == ENFILE)) {
if (--retry < 0)
return EXIT_NO_RESOURCE;
} else {
pr_fail_err("mmap");
}
} else {
break;
}
}
(void)memset(mem, 0, mmap_size);
for (i = 0; i < tlb_procs; i++)
pids[i] = -1;
for (i = 0; i < tlb_procs; i++) {
int32_t j, cpu = -1;
for (j = 0; j < max_cpus; j++) {
if (CPU_ISSET(j, &proc_mask)) {
cpu = j;
CPU_CLR(j, &proc_mask);
break;
}
}
if (cpu == -1)
break;
pids[i] = fork();
if (pids[i] < 0)
break;
if (pids[i] == 0) {
cpu_set_t mask;
char buffer[page_size];
(void)setpgid(0, g_pgrp);
stress_parent_died_alarm();
/* Make sure this is killable by OOM killer */
set_oom_adjustment(args->name, true);
CPU_ZERO(&mask);
CPU_SET(cpu % max_cpus, &mask);
(void)sched_setaffinity(args->pid, sizeof(mask), &mask);
for (ptr = mem; ptr < mem + mmap_size; ptr += page_size) {
/* Force tlb shoot down on page */
(void)mprotect(ptr, page_size, PROT_READ);
(void)memcpy(buffer, ptr, page_size);
(void)munmap(ptr, page_size);
}
_exit(0);
}
}
for (i = 0; i < tlb_procs; i++) {
if (pids[i] != -1) {
int status, ret;
ret = shim_waitpid(pids[i], &status, 0);
if ((ret < 0) && (errno == EINTR)) {
int j;
/*
* We got interrupted, so assume
* it was the alarm (timedout) or
* SIGINT so force terminate
*/
for (j = i; j < tlb_procs; j++) {
if (pids[j] != -1)
(void)kill(pids[j], SIGKILL);
}
/* re-wait on the failed wait */
(void)shim_waitpid(pids[i], &status, 0);
/* and continue waitpid on the pids */
}
}
}
(void)munmap(mem, mmap_size);
(void)sched_setaffinity(0, sizeof(proc_mask_initial), &proc_mask_initial);
inc_counter(args);
} while (keep_stressing());
return EXIT_SUCCESS;
}
/*
* This is called 'cipher in counter mode'.
*/
static void
encrypt_counter(FState * st, uint8 *dst)
{
ciph_encrypt(&st->ciph, st->counter, dst);
inc_counter(st);
}
/*
* stress_kcmp
* stress sys_kcmp
*/
static int stress_kcmp(const args_t *args)
{
pid_t pid1;
int fd1;
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
int efd, sfd;
int so_reuseaddr = 1;
struct epoll_event ev;
struct sockaddr *addr = NULL;
socklen_t addr_len = 0;
#endif
int ret = EXIT_SUCCESS;
static const char *capfail =
"need CAP_SYS_PTRACE capability to run kcmp stressor, "
"aborting stress test\n";
if ((fd1 = open("/dev/null", O_WRONLY)) < 0) {
pr_fail_err("open");
return EXIT_FAILURE;
}
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
efd = -1;
if ((sfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
sfd = -1;
goto again;
}
if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR,
&so_reuseaddr, sizeof(so_reuseaddr)) < 0) {
(void)close(sfd);
sfd = -1;
goto again;
}
stress_set_sockaddr(args->name, args->instance, args->ppid,
AF_INET, 23000, &addr, &addr_len, NET_ADDR_ANY);
if (bind(sfd, addr, addr_len) < 0) {
(void)close(sfd);
sfd = -1;
goto again;
}
if (listen(sfd, SOMAXCONN) < 0) {
(void)close(sfd);
sfd = -1;
goto again;
}
efd = epoll_create1(0);
if (efd < 0) {
(void)close(sfd);
sfd = -1;
efd = -1;
goto again;
}
(void)memset(&ev, 0, sizeof(ev));
ev.data.fd = efd;
ev.events = EPOLLIN | EPOLLET;
if (epoll_ctl(efd, EPOLL_CTL_ADD, sfd, &ev) < 0) {
(void)close(sfd);
(void)close(efd);
sfd = -1;
efd = -1;
}
#endif
again:
pid1 = fork();
if (pid1 < 0) {
if (g_keep_stressing_flag &&
((errno == EAGAIN) || (errno == ENOMEM)))
goto again;
pr_fail_dbg("fork");
(void)close(fd1);
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (sfd != -1)
(void)close(sfd);
#endif
return EXIT_FAILURE;
} else if (pid1 == 0) {
(void)setpgid(0, g_pgrp);
stress_parent_died_alarm();
/* Child */
while (g_keep_stressing_flag)
(void)pause();
/* will never get here */
(void)close(fd1);
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (efd != -1)
(void)close(efd);
if (sfd != -1)
(void)close(sfd);
#endif
_exit(EXIT_SUCCESS);
} else {
/* Parent */
int fd2, status, pid2;
(void)setpgid(pid1, g_pgrp);
pid2 = getpid();
if ((fd2 = open("/dev/null", O_WRONLY)) < 0) {
pr_fail_err("open");
ret = EXIT_FAILURE;
goto reap;
}
do {
KCMP(pid1, pid2, SHIM_KCMP_FILE, fd1, fd2);
KCMP(pid1, pid1, SHIM_KCMP_FILE, fd1, fd1);
KCMP(pid2, pid2, SHIM_KCMP_FILE, fd1, fd1);
KCMP(pid2, pid2, SHIM_KCMP_FILE, fd2, fd2);
KCMP(pid1, pid2, SHIM_KCMP_FILES, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_FILES, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_FILES, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_FS, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_FS, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_FS, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_IO, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_IO, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_IO, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_SIGHAND, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_SIGHAND, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_SIGHAND, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_SYSVSEM, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_SYSVSEM, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_SYSVSEM, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_VM, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_VM, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_VM, 0, 0);
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (efd != -1) {
struct kcmp_epoll_slot slot;
slot.efd = efd;
slot.tfd = sfd;
slot.toff = 0;
KCMP(pid1, pid2, SHIM_KCMP_EPOLL_TFD, efd, (unsigned long)&slot);
KCMP(pid2, pid1, SHIM_KCMP_EPOLL_TFD, efd, (unsigned long)&slot);
KCMP(pid2, pid2, SHIM_KCMP_EPOLL_TFD, efd, (unsigned long)&slot);
}
#endif
/* Same simple checks */
if (g_opt_flags & OPT_FLAGS_VERIFY) {
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_FILE, fd1, fd1, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_FILES, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_FS, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_IO, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_SIGHAND, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_SYSVSEM, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_VM, 0, 0, 0);
KCMP_VERIFY(pid1, pid2, SHIM_KCMP_SYSVSEM, 0, 0, 0);
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (efd != -1) {
struct kcmp_epoll_slot slot;
slot.efd = efd;
slot.tfd = sfd;
slot.toff = 0;
KCMP(pid1, pid2, SHIM_KCMP_EPOLL_TFD, efd, (unsigned long)&slot);
}
#endif
}
inc_counter(args);
} while (keep_stressing());
reap:
if (fd2 >= 0)
(void)close(fd2);
(void)kill(pid1, SIGKILL);
(void)shim_waitpid(pid1, &status, 0);
(void)close(fd1);
}
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (efd != -1)
(void)close(efd);
if (sfd != -1)
(void)close(sfd);
#endif
return ret;
}
/*
* stress_remap
* stress page remapping
*/
static int stress_remap(const args_t *args)
{
mapdata_t *data;
const size_t page_size = args->page_size;
const size_t data_size = N_PAGES * page_size;
const size_t stride = page_size / sizeof(*data);
size_t i;
data = mmap(NULL, data_size, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (data == MAP_FAILED) {
pr_err("%s: mmap failed: errno=%d (%s)\n",
args->name, errno, strerror(errno));
return EXIT_NO_RESOURCE;
}
for (i = 0; i < N_PAGES; i++)
data[i * stride] = i;
do {
size_t order[N_PAGES];
/* Reverse pages */
for (i = 0; i < N_PAGES; i++)
order[i] = N_PAGES - 1 - i;
if (remap_order(args, stride, data, order, page_size) < 0)
break;
check_order(args, stride, data, order, "reverse");
/* random order pages */
for (i = 0; i < N_PAGES; i++)
order[i] = i;
for (i = 0; i < N_PAGES; i++) {
size_t tmp, j = mwc32() % N_PAGES;
tmp = order[i];
order[i] = order[j];
order[j] = tmp;
}
if (remap_order(args, stride, data, order, page_size) < 0)
break;
check_order(args, stride, data, order, "random");
/* all mapped to 1 page */
for (i = 0; i < N_PAGES; i++)
order[i] = 0;
if (remap_order(args, stride, data, order, page_size) < 0)
break;
check_order(args, stride, data, order, "all-to-1");
/* reorder pages back again */
for (i = 0; i < N_PAGES; i++)
order[i] = i;
if (remap_order(args, stride, data, order, page_size) < 0)
break;
check_order(args, stride, data, order, "forward");
inc_counter(args);
} while (keep_stressing());
(void)munmap(data, data_size);
return EXIT_SUCCESS;
}
