chiark - git - ian - stressapptest/blob - src/sattypes.h

   1 // Copyright 2006 Google Inc. All Rights Reserved.
   2
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6
   7 //      http://www.apache.org/licenses/LICENSE-2.0
   8
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #ifndef STRESSAPPTEST_SATTYPES_H_
  16 #define STRESSAPPTEST_SATTYPES_H_
  17
  18 #include <arpa/inet.h>
  19 #include <sched.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <sys/types.h>
  23 #include <time.h>
  24 #include <string.h>
  25 #include <algorithm>
  26 #include <string>
  27
  28 #ifdef HAVE_CONFIG_H  // Built using autoconf
  29 #ifdef __ANDROID__
  30 #include "stressapptest_config_android.h"  // NOLINT
  31 #else
  32 #include "stressapptest_config.h"  // NOLINT
  33 using namespace __gnu_cxx;  //NOLINT
  34 #endif  // __ANDROID__
  35 using namespace std;
  36
  37 typedef signed long long   int64;
  38 typedef signed int         int32;
  39 typedef signed short int   int16;
  40 typedef signed char        int8;
  41
  42 typedef unsigned long long uint64;
  43 typedef unsigned int       uint32;
  44 typedef unsigned short     uint16;
  45 typedef unsigned char      uint8;
  46
  47 #define DISALLOW_COPY_AND_ASSIGN(TypeName)        \
  48   TypeName(const TypeName&);                      \
  49   void operator=(const TypeName&)
  50
  51 inline const char* Timestamp() {
  52   return STRESSAPPTEST_TIMESTAMP;
  53 }
  54
  55 inline const char* BuildChangelist() {
  56   return "open source release";
  57 }
  58
  59 static const bool kOpenSource = true;
  60 #else  // !HAVE_CONFIG_H
  61 static const bool kOpenSource = false;
  62   #include "googlesattypes.h"  // NOLINT
  63 #endif  // HAVE_CONFIG_H
  64 // Workaround to allow 32/64 bit conversion
  65 // without running into strict aliasing problems.
  66 union datacast_t {
  67   uint64 l64;
  68   struct {
  69     uint32 l;
  70     uint32 h;
  71   } l32;
  72 };
  73
  74
  75 // File sync'd print to console and log
  76 void logprintf(int priority, const char *format, ...);
  77
  78 // Stop the log and dump any queued lines.
  79 void logstop();
  80
  81 // We print to stderr ourselves first in case we're in such a bad state that the
  82 // logger can't work.
  83 #define sat_assert(x) \
  84 {\
  85   if (!(x)) {\
  86     logstop();\
  87     fprintf(stderr, "Assertion failed at %s:%d\n", __FILE__, __LINE__);\
  88     logprintf(0, "Assertion failed at %s:%d\n", __FILE__, __LINE__);\
  89     exit(1);\
  90   }\
  91 }
  92
  93 #if !defined(CPU_SETSIZE)
  94   // Define type and macros for cpu mask operations
  95   // Note: this code is hacked together to deal with difference
  96   // function signatures across versions of glibc, ie those that take
  97   // cpu_set_t versus those that take unsigned long.  -johnhuang
  98   typedef uint64 cpu_set_t;
  99   #define CPU_SETSIZE                   (sizeof(cpu_set_t) * 8)
 100   #define CPU_ISSET(index, cpu_set_ptr) (*(cpu_set_ptr) & 1ull << (index))
 101   #define CPU_SET(index, cpu_set_ptr)   (*(cpu_set_ptr) |= 1ull << (index))
 102   #define CPU_ZERO(cpu_set_ptr)         (*(cpu_set_ptr) = 0)
 103   #define CPU_CLR(index, cpu_set_ptr)   (*(cpu_set_ptr) &= ~(1ull << (index)))
 104 #endif
 105
 106 static inline bool cpuset_isequal(const cpu_set_t *c1, const cpu_set_t *c2) {
 107   for (int i = 0; i < CPU_SETSIZE; ++i)
 108     if ((CPU_ISSET(i, c1) != 0) != (CPU_ISSET(i, c2) != 0))
 109       return false;
 110   return true;
 111 }
 112
 113 static inline bool cpuset_issubset(const cpu_set_t *c1, const cpu_set_t *c2) {
 114   for (int i = 0; i < CPU_SETSIZE; ++i)
 115     if (CPU_ISSET(i, c1) && !CPU_ISSET(i, c2))
 116       return false;
 117   return true;
 118 }
 119
 120 static inline int cpuset_count(const cpu_set_t *cpuset) {
 121   int count = 0;
 122   for (int i = 0; i < CPU_SETSIZE; ++i)
 123     if (CPU_ISSET(i, cpuset))
 124       ++count;
 125   return count;
 126 }
 127
 128 static inline void cpuset_set_ab(cpu_set_t *cpuset, int a, int b) {
 129   CPU_ZERO(cpuset);
 130   for (int i = a; i < b; ++i)
 131     CPU_SET(i, cpuset);
 132 }
 133
 134 static inline string cpuset_format(const cpu_set_t *cpuset) {
 135   string format;
 136   int digit = 0, last_non_zero_size = 1;
 137   for (int i = 0; i < CPU_SETSIZE; ++i) {
 138     if (CPU_ISSET(i, cpuset)) {
 139       digit |= 1 << (i & 3);
 140     }
 141     if ((i & 3) == 3) {
 142       format += char(digit <= 9 ? '0' + digit: 'A' + digit - 10);
 143       if (digit) {
 144         last_non_zero_size = format.size();
 145         digit = 0;
 146       }
 147     }
 148   }
 149   if (digit) {
 150     format += char(digit <= 9 ? '0' + digit: 'A' + digit - 10);
 151     last_non_zero_size = format.size();
 152   }
 153   format.erase(last_non_zero_size);
 154   reverse(format.begin(), format.end());
 155   return format;
 156 }
 157
 158 static const int32 kUSleepOneSecond = 1000000;
 159
 160 // This is guaranteed not to use signals.
 161 inline bool sat_usleep(int32 microseconds) {
 162   timespec req;
 163   req.tv_sec = microseconds / 1000000;
 164   // Convert microseconds argument to nano seconds.
 165   req.tv_nsec = (microseconds % 1000000) * 1000;
 166   return nanosleep(&req, NULL) == 0;
 167 }
 168
 169 // This is guaranteed not to use signals.
 170 inline bool sat_sleep(time_t seconds) {
 171   timespec req;
 172   req.tv_sec = seconds;
 173   req.tv_nsec = 0;
 174   return nanosleep(&req, NULL) == 0;
 175 }
 176
 177 // Get an error code description for use in error messages.
 178 //
 179 // Args:
 180 //   error_num: an errno error code
 181 inline string ErrorString(int error_num) {
 182   char buf[256];
 183 #ifdef STRERROR_R_CHAR_P
 184   return string(strerror_r(error_num, buf, sizeof buf));
 185 #else
 186   if (strerror_r(error_num, buf, sizeof buf))
 187     return "unknown failure";
 188   else
 189     return string(buf);
 190 #endif
 191 }
 192
 193 // Execute the cpuid instruction and pass back the contents of the registers.
 194 // This only works on x86 based platforms.
 195 inline void cpuid(
 196   unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx) {
 197   *ebx = 0;
 198   *ecx = 0;
 199   *edx = 0;
 200   // CPUID features documented at:
 201   // http://www.sandpile.org/ia32/cpuid.htm
 202 #if defined(STRESSAPPTEST_CPU_I686) || defined(STRESSAPPTEST_CPU_X86_64)
 203 #if defined(__PIC__) && defined(STRESSAPPTEST_CPU_I686)
 204   // In PIC compilations using the i686 cpu type, ebx contains the address
 205   // of the global offset table. The compiler can't properly handle constraints
 206   // using the ebx register for this compile, so preserve the register
 207   // ourselves.
 208   asm(
 209     "mov %%ebx, %%edi;"
 210     "cpuid;"
 211     "xchg %%edi, %%ebx;"
 212     // Output registers.
 213     : "=a" (*eax), "=D" (*ebx), "=c" (*ecx), "=d" (*edx)
 214     // Input registers.
 215     : "a" (*eax)
 216   );  // Asm
 217 #else
 218   asm(
 219     "cpuid;"
 220     // Output registers.
 221     : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
 222     // Input registers.
 223     : "a" (*eax)
 224   );  // Asm
 225 #endif  // defined(__PIC__) && defined(STRESSAPPTEST_CPU_I686)
 226 #elif defined(STRESSAPPTEST_CPU_PPC)
 227   return;
 228 #elif defined(STRESSAPPTEST_CPU_ARMV7A)
 229   return;
 230 #elif defined(STRESSAPPTEST_CPU_AARCH64)
 231   return;
 232 #else
 233 #warning "Unsupported CPU type."
 234 #endif
 235 }
 236
 237 // Define handy constants here
 238 static const int kTicksPerSec = 100;
 239 static const int kMegabyte = (1024LL*1024LL);
 240 static const int kSatDiskPageMax = 32;
 241 static const int kSatDiskPage = 8;
 242 static const int kSatPageSize = (1024LL*1024LL);
 243 static const int kCacheLineSize = 64;
 244 static const uint16_t kNetworkPort = 22;
 245
 246 #endif  // STRESSAPPTEST_SATTYPES_H_