chiark - git - ian - stressapptest/blob - src/sat.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 // sat.h : sat stress test object interface and data structures
  16
  17 #ifndef STRESSAPPTEST_SAT_H_
  18 #define STRESSAPPTEST_SAT_H_
  19
  20 #include <signal.h>
  21
  22 #include <map>
  23 #include <string>
  24 #include <vector>
  25
  26 // This file must work with autoconf on its public version,
  27 // so these includes are correct.
  28 #include "finelock_queue.h"
  29 #include "queue.h"
  30 #include "sattypes.h"
  31 #include "worker.h"
  32 #include "os.h"
  33
  34 // SAT stress test class.
  35 class Sat {
  36  public:
  37   // Enum for page queue implementation switch.
  38   enum PageQueueType { SAT_ONELOCK, SAT_FINELOCK };
  39
  40   Sat();
  41   virtual ~Sat();
  42
  43   // Read configuration from arguments. Called first.
  44   bool ParseArgs(int argc, char **argv);
  45   virtual bool CheckGoogleSpecificArgs(int argc, char **argv, int *i);
  46   // Initialize data structures, subclasses, and resources,
  47   // based on command line args.
  48   // Called after ParseArgs().
  49   bool Initialize();
  50
  51   // Execute the test. Initialize() and ParseArgs() must be called first.
  52   // This must be called from a single-threaded program.
  53   bool Run();
  54
  55   // Pretty print result summary.
  56   // Called after Run().
  57   // Return value is success or failure of the SAT run, *not* of this function!
  58   bool PrintResults();
  59
  60   // Pretty print version info.
  61   bool PrintVersion();
  62
  63   // Pretty print help.
  64   virtual void PrintHelp();
  65
  66   // Clean up allocations and resources.
  67   // Called last.
  68   bool Cleanup();
  69
  70   // Abort Run().  Only for use by Run()-installed signal handlers.
  71   void Break() { user_break_ = true; }
  72
  73   // Fetch and return empty and full pages into the empty and full pools.
  74   bool GetValid(struct page_entry *pe);
  75   bool PutValid(struct page_entry *pe);
  76   bool GetEmpty(struct page_entry *pe);
  77   bool PutEmpty(struct page_entry *pe);
  78
  79   bool GetValid(struct page_entry *pe, int32 tag);
  80   bool GetEmpty(struct page_entry *pe, int32 tag);
  81
  82   // Accessor functions.
  83   int verbosity() const { return verbosity_; }
  84   int logfile() const { return logfile_; }
  85   int page_length() const { return page_length_; }
  86   int disk_pages() const { return disk_pages_; }
  87   int strict() const { return strict_; }
  88   int tag_mode() const { return tag_mode_; }
  89   int status() const { return statuscount_; }
  90   void bad_status() { statuscount_++; }
  91   int errors() const { return errorcount_; }
  92   int warm() const { return warm_; }
  93   bool stop_on_error() const { return stop_on_error_; }
  94   int32 region_mask() const { return region_mask_; }
  95   // Semi-accessor to find the "nth" region to avoid replicated bit searching..
  96   int32 region_find(int32 num) const {
  97     for (int i = 0; i < 32; i++) {
  98       if ((1 << i) & region_mask_) {
  99         if (num == 0)
 100           return i;
 101         num--;
 102       }
 103     }
 104     return 0;
 105   }
 106
 107   // Causes false errors for unittesting.
 108   // Setting to "true" causes errors to be injected.
 109   void set_error_injection(bool errors) { error_injection_ = errors; }
 110   bool error_injection() const { return error_injection_; }
 111
 112  protected:
 113   // Opens log file for writing. Returns 0 on failure.
 114   bool InitializeLogfile();
 115   // Checks for supported environment. Returns 0 on failure.
 116   bool CheckEnvironment();
 117   // Allocates size_ bytes of test memory.
 118   bool AllocateMemory();
 119   // Initializes datapattern reference structures.
 120   bool InitializePatterns();
 121   // Initializes test memory with datapatterns.
 122   bool InitializePages();
 123
 124   // Start up worker threads.
 125   virtual void InitializeThreads();
 126   // Spawn worker threads.
 127   void SpawnThreads();
 128   // Reap worker threads.
 129   void JoinThreads();
 130   // Run bandwidth and error analysis.
 131   virtual void RunAnalysis();
 132   // Delete worker threads.
 133   void DeleteThreads();
 134
 135   // Return the number of cpus in the system.
 136   int CpuCount();
 137
 138   // Collect error counts from threads.
 139   int64 GetTotalErrorCount();
 140
 141   // Command line arguments.
 142   string cmdline_;
 143
 144   // Memory and test configuration.
 145   int runtime_seconds_;               // Seconds to run.
 146   int page_length_;                   // Length of each memory block.
 147   int64 pages_;                       // Number of memory blocks.
 148   int64 size_;                        // Size of memory tested, in bytes.
 149   int64 size_mb_;                     // Size of memory tested, in MB.
 150   int64 min_hugepages_mbytes_;        // Minimum hugepages size.
 151   int64 freepages_;                   // How many invalid pages we need.
 152   int disk_pages_;                    // Number of pages per temp file.
 153   uint64 paddr_base_;                 // Physical address base.
 154   vector< vector<string> > channels_; // Memory module names per channel.
 155   uint64 channel_hash_;               // Mask of address bits XORed for channel.
 156   int channel_width_;                 // Channel width in bits.
 157
 158   // Control flags.
 159   volatile sig_atomic_t user_break_;  // User has signalled early exit.  Used as
 160                                       // a boolean.
 161   int verbosity_;                     // How much to print.
 162   int strict_;                        // Check results per transaction.
 163   int warm_;                          // FPU warms CPU while coying.
 164   int address_mode_;                  // 32 or 64 bit binary.
 165   bool stop_on_error_;                // Exit immendiately on any error.
 166   bool findfiles_;                    // Autodetect tempfile locations.
 167
 168   bool error_injection_;              // Simulate errors, for unittests.
 169   bool crazy_error_injection_;        // Simulate lots of errors.
 170   uint64 max_errorcount_;             // Number of errors before forced exit.
 171   int run_on_anything_;               // Ignore unknown machine ereor.
 172   int use_logfile_;                   // Log to a file.
 173   char logfilename_[255];             // Name of file to log to.
 174   int logfile_;                       // File handle to log to.
 175
 176   // Disk thread options.
 177   int read_block_size_;               // Size of block to read from disk.
 178   int write_block_size_;              // Size of block to write to disk.
 179   int64 segment_size_;                // Size of segment to split disk into.
 180   int cache_size_;                    // Size of disk cache.
 181   int blocks_per_segment_;            // Number of blocks to test per segment.
 182   int read_threshold_;                // Maximum time (in us) a read should take
 183                                       // before warning of a slow read.
 184   int write_threshold_;               // Maximum time (in us) a write should
 185                                       // take before warning of a slow write.
 186   int non_destructive_;               // Whether to use non-destructive mode for
 187                                       // the disk test.
 188
 189   // Generic Options.
 190   int monitor_mode_;                  // Switch for monitor-only mode SAT.
 191                                       // This switch trumps most of the other
 192                                       // argument, as SAT will only run error
 193                                       // polling threads.
 194   int tag_mode_;                      // Do tagging of memory and strict
 195                                       // checking for misplaced cachelines.
 196
 197   bool do_page_map_;                  // Should we print a list of used pages?
 198   unsigned char *page_bitmap_;        // Store bitmap of physical pages seen.
 199   uint64 page_bitmap_size_;           // Length of physical memory represented.
 200
 201   // Cpu Cache Coherency Options.
 202   bool cc_test_;                      // Flag to decide whether to start the
 203                                       // cache coherency threads.
 204   int cc_cacheline_count_;            // Number of cache line size structures.
 205   int cc_inc_count_;                  // Number of times to increment the shared
 206                                       // cache lines structure members.
 207
 208   // Thread control.
 209   int file_threads_;                  // Threads of file IO.
 210   int net_threads_;                   // Threads of network IO.
 211   int listen_threads_;                // Threads for network IO to connect.
 212   int memory_threads_;                // Threads of memcpy.
 213   int invert_threads_;                // Threads of invert.
 214   int fill_threads_;                  // Threads of memset.
 215   int check_threads_;                 // Threads of strcmp.
 216   int cpu_stress_threads_;            // Threads of CPU stress workload.
 217   int disk_threads_;                  // Threads of disk test.
 218   int random_threads_;                // Number of random disk threads.
 219   int total_threads_;                 // Total threads used.
 220   bool error_poll_;                   // Poll for system errors.
 221
 222   // Resources.
 223   cc_cacheline_data *cc_cacheline_data_;  // The cache line sized datastructure
 224                                           // used by the ccache threads
 225                                           // (in worker.h).
 226   vector<string> filename_;           // Filenames for file IO.
 227   vector<string> ipaddrs_;            // Addresses for network IO.
 228   vector<string> diskfilename_;       // Filename for disk IO device.
 229   // Block table for IO device.
 230   vector<DiskBlockTable*> blocktables_;
 231
 232   int32 region_mask_;                 // Bitmask of available NUMA regions.
 233   int32 region_count_;                // Count of available NUMA regions.
 234   int32 region_[32];                  // Pagecount per region.
 235   int region_mode_;                   // What to do with NUMA hints?
 236   static const int kLocalNuma = 1;    // Target local memory.
 237   static const int kRemoteNuma = 2;   // Target remote memory.
 238
 239   // Results.
 240   int64 errorcount_;                  // Total hardware incidents seen.
 241   int statuscount_;                   // Total test errors seen.
 242
 243   // Thread type constants and types
 244   enum ThreadType {
 245     kMemoryType = 0,
 246     kFileIOType = 1,
 247     kNetIOType = 2,
 248     kNetSlaveType = 3,
 249     kCheckType = 4,
 250     kInvertType = 5,
 251     kDiskType = 6,
 252     kRandomDiskType = 7,
 253     kCPUType = 8,
 254     kErrorType = 9,
 255     kCCType = 10
 256   };
 257
 258   // Helper functions.
 259   virtual void AcquireWorkerLock();
 260   virtual void ReleaseWorkerLock();
 261   pthread_mutex_t worker_lock_;  // Lock access to the worker thread structure.
 262   typedef vector<WorkerThread*> WorkerVector;
 263   typedef map<int, WorkerVector*> WorkerMap;
 264   // Contains all worker threads.
 265   WorkerMap workers_map_;
 266   // Delay between power spikes.
 267   time_t pause_delay_;
 268   // The duration of each pause (for power spikes).
 269   time_t pause_duration_;
 270   // For the workers we pause and resume to create power spikes.
 271   WorkerStatus power_spike_status_;
 272   // For the workers we never pause.
 273   WorkerStatus continuous_status_;
 274
 275   class OsLayer *os_;                   // Os abstraction: put hacks here.
 276   class PatternList *patternlist_;      // Access to global data patterns.
 277
 278   // RunAnalysis methods
 279   void AnalysisAllStats();              // Summary of all runs.
 280   void MemoryStats();
 281   void FileStats();
 282   void NetStats();
 283   void CheckStats();
 284   void InvertStats();
 285   void DiskStats();
 286
 287   void QueueStats();
 288
 289   // Physical page use reporting.
 290   void AddrMapInit();
 291   void AddrMapUpdate(struct page_entry *pe);
 292   void AddrMapPrint();
 293
 294   // additional memory data from google-specific tests.
 295   virtual void GoogleMemoryStats(float *memcopy_data,
 296                                  float *memcopy_bandwidth);
 297
 298   virtual void GoogleOsOptions(std::map<std::string, std::string> *options);
 299
 300   // Page queues, only one of (valid_+empty_) or (finelock_q_) will be used
 301   // at a time. A commandline switch controls which queue implementation will
 302   // be used.
 303   class PageEntryQueue *valid_;        // Page queue structure, valid pages.
 304   class PageEntryQueue *empty_;        // Page queue structure, free pages.
 305   class FineLockPEQueue *finelock_q_;  // Page queue with fine-grain locks
 306   Sat::PageQueueType pe_q_implementation_;   // Queue implementation switch
 307
 308   DISALLOW_COPY_AND_ASSIGN(Sat);
 309 };
 310
 311 Sat *SatFactory();
 312
 313 #endif  // STRESSAPPTEST_SAT_H_