#include <sys/types.h>
#include <time.h>
#include <string.h>
+#include <algorithm>
#include <string>
#ifdef HAVE_CONFIG_H // Built using autoconf
-#include "stressapptest_config.h"
+#ifdef __ANDROID__
+#include "stressapptest_config_android.h" // NOLINT
+#else
+#include "stressapptest_config.h" // NOLINT
+using namespace __gnu_cxx; //NOLINT
+#endif // __ANDROID__
using namespace std;
-using namespace __gnu_cxx;
typedef signed long long int64;
typedef signed int int32;
}
static const bool kOpenSource = true;
-#else
+#else // !HAVE_CONFIG_H
static const bool kOpenSource = false;
- #include "googlesattypes.h"
-#endif
+ #include "googlesattypes.h" // NOLINT
+#endif // HAVE_CONFIG_H
// Workaround to allow 32/64 bit conversion
// without running into strict aliasing problems.
union datacast_t {
// File sync'd print to console and log
void logprintf(int priority, const char *format, ...);
+// Stop the log and dump any queued lines.
+void logstop();
+
// We print to stderr ourselves first in case we're in such a bad state that the
// logger can't work.
#define sat_assert(x) \
{\
if (!(x)) {\
+ logstop();\
fprintf(stderr, "Assertion failed at %s:%d\n", __FILE__, __LINE__);\
logprintf(0, "Assertion failed at %s:%d\n", __FILE__, __LINE__);\
exit(1);\
// Note: this code is hacked together to deal with difference
// function signatures across versions of glibc, ie those that take
// cpu_set_t versus those that take unsigned long. -johnhuang
- typedef unsigned long cpu_set_t;
- #define CPU_SETSIZE 32
- #define CPU_ISSET(index, cpu_set_ptr) (*(cpu_set_ptr) & 1 << (index))
- #define CPU_SET(index, cpu_set_ptr) (*(cpu_set_ptr) |= 1 << (index))
+ typedef uint64 cpu_set_t;
+ #define CPU_SETSIZE (sizeof(cpu_set_t) * 8)
+ #define CPU_ISSET(index, cpu_set_ptr) (*(cpu_set_ptr) & 1ull << (index))
+ #define CPU_SET(index, cpu_set_ptr) (*(cpu_set_ptr) |= 1ull << (index))
#define CPU_ZERO(cpu_set_ptr) (*(cpu_set_ptr) = 0)
- #define CPU_CLR(index, cpu_set_ptr) (*(cpu_set_ptr) &= ~(1 << (index)))
+ #define CPU_CLR(index, cpu_set_ptr) (*(cpu_set_ptr) &= ~(1ull << (index)))
#endif
-// Make using CPUSET non-super-painful.
-static inline uint32 cpuset_to_uint32(cpu_set_t *cpuset) {
- uint32 value = 0;
- for (int index = 0; index < CPU_SETSIZE; index++) {
- if (CPU_ISSET(index, cpuset)) {
- if (index < 32) {
- value |= 1 << index;
- } else {
- logprintf(0, "Process Error: Cpu index (%d) higher than 32\n", index);
- sat_assert(0);
- }
- }
- }
- return value;
+static inline bool cpuset_isequal(const cpu_set_t *c1, const cpu_set_t *c2) {
+ for (int i = 0; i < CPU_SETSIZE; ++i)
+ if ((CPU_ISSET(i, c1) != 0) != (CPU_ISSET(i, c2) != 0))
+ return false;
+ return true;
+}
+
+static inline bool cpuset_issubset(const cpu_set_t *c1, const cpu_set_t *c2) {
+ for (int i = 0; i < CPU_SETSIZE; ++i)
+ if (CPU_ISSET(i, c1) && !CPU_ISSET(i, c2))
+ return false;
+ return true;
}
-static inline void cpuset_from_uint32(uint32 mask, cpu_set_t *cpuset) {
+static inline int cpuset_count(const cpu_set_t *cpuset) {
+ int count = 0;
+ for (int i = 0; i < CPU_SETSIZE; ++i)
+ if (CPU_ISSET(i, cpuset))
+ ++count;
+ return count;
+}
+
+static inline void cpuset_set_ab(cpu_set_t *cpuset, int a, int b) {
CPU_ZERO(cpuset);
- for (int index = 0; index < 32; index++) {
- if (mask & (1 << index))
- CPU_SET(index, cpuset);
+ for (int i = a; i < b; ++i)
+ CPU_SET(i, cpuset);
+}
+
+static inline string cpuset_format(const cpu_set_t *cpuset) {
+ string format;
+ int digit = 0, last_non_zero_size = 1;
+ for (int i = 0; i < CPU_SETSIZE; ++i) {
+ if (CPU_ISSET(i, cpuset)) {
+ digit |= 1 << (i & 3);
+ }
+ if ((i & 3) == 3) {
+ format += char(digit <= 9 ? '0' + digit: 'A' + digit - 10);
+ if (digit) {
+ last_non_zero_size = format.size();
+ digit = 0;
+ }
+ }
+ }
+ if (digit) {
+ format += char(digit <= 9 ? '0' + digit: 'A' + digit - 10);
+ last_non_zero_size = format.size();
}
+ format.erase(last_non_zero_size);
+ reverse(format.begin(), format.end());
+ return format;
}
static const int32 kUSleepOneSecond = 1000000;
// error_num: an errno error code
inline string ErrorString(int error_num) {
char buf[256];
+#ifdef STRERROR_R_CHAR_P
return string(strerror_r(error_num, buf, sizeof buf));
+#else
+ if (strerror_r(error_num, buf, sizeof buf))
+ return "unknown failure";
+ else
+ return string(buf);
+#endif
+}
+
+// Execute the cpuid instruction and pass back the contents of the registers.
+// This only works on x86 based platforms.
+inline void cpuid(
+ unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx) {
+ *ebx = 0;
+ *ecx = 0;
+ *edx = 0;
+ // CPUID features documented at:
+ // http://www.sandpile.org/ia32/cpuid.htm
+#if defined(STRESSAPPTEST_CPU_I686) || defined(STRESSAPPTEST_CPU_X86_64)
+#if defined(__PIC__) && defined(STRESSAPPTEST_CPU_I686)
+ // In PIC compilations using the i686 cpu type, ebx contains the address
+ // of the global offset table. The compiler can't properly handle constraints
+ // using the ebx register for this compile, so preserve the register
+ // ourselves.
+ asm(
+ "mov %%ebx, %%edi;"
+ "cpuid;"
+ "xchg %%edi, %%ebx;"
+ // Output registers.
+ : "=a" (*eax), "=D" (*ebx), "=c" (*ecx), "=d" (*edx)
+ // Input registers.
+ : "a" (*eax)
+ ); // Asm
+#else
+ asm(
+ "cpuid;"
+ // Output registers.
+ : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
+ // Input registers.
+ : "a" (*eax)
+ ); // Asm
+#endif // defined(__PIC__) && defined(STRESSAPPTEST_CPU_I686)
+#elif defined(STRESSAPPTEST_CPU_PPC)
+ return;
+#elif defined(STRESSAPPTEST_CPU_ARMV7A)
+ return;
+#elif defined(STRESSAPPTEST_CPU_AARCH64)
+ return;
+#else
+#warning "Unsupported CPU type."
+#endif
}
// Define handy constants here
static const int kSatDiskPage = 8;
static const int kSatPageSize = (1024LL*1024LL);
static const int kCacheLineSize = 64;
-static const uint16_t kNetworkPort = 19996;
+static const uint16_t kNetworkPort = 22;
#endif // STRESSAPPTEST_SATTYPES_H_
~ian / stressapptest / blobdiff