1 // Copyright 2006 Google Inc. All Rights Reserved.
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
7 // http://www.apache.org/licenses/LICENSE-2.0
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.
15 // sat.h : sat stress test object interface and data structures
17 #ifndef STRESSAPPTEST_SAT_H_
18 #define STRESSAPPTEST_SAT_H_
26 // This file must work with autoconf on its public version,
27 // so these includes are correct.
28 #include "finelock_queue.h"
34 // SAT stress test class.
37 // Enum for page queue implementation switch.
38 enum PageQueueType { SAT_ONELOCK, SAT_FINELOCK };
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().
51 // Execute the test. Initialize() and ParseArgs() must be called first.
52 // This must be called from a single-threaded program.
55 // Pretty print result summary.
56 // Called after Run().
57 // Return value is success or failure of the SAT run, *not* of this function!
60 // Pretty print version info.
64 virtual void PrintHelp();
66 // Clean up allocations and resources.
70 // Abort Run(). Only for use by Run()-installed signal handlers.
71 void Break() { user_break_ = true; }
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);
79 bool GetValid(struct page_entry *pe, int32 tag);
80 bool GetEmpty(struct page_entry *pe, int32 tag);
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_) {
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_; }
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();
124 // Start up worker threads.
125 virtual void InitializeThreads();
126 // Spawn worker threads.
128 // Reap worker threads.
130 // Run bandwidth and error analysis.
131 virtual void RunAnalysis();
132 // Delete worker threads.
133 void DeleteThreads();
135 // Return the number of cpus in the system.
137 // Return the worst-case (largest) cache line size of the system.
140 // Collect error counts from threads.
141 int64 GetTotalErrorCount();
143 // Command line arguments.
146 // Memory and test configuration.
147 int runtime_seconds_; // Seconds to run.
148 int page_length_; // Length of each memory block.
149 int64 pages_; // Number of memory blocks.
150 int64 size_; // Size of memory tested, in bytes.
151 int64 size_mb_; // Size of memory tested, in MB.
152 int64 reserve_mb_; // Reserve at least this amount of memory
153 // for the system, in MB.
154 int64 min_hugepages_mbytes_; // Minimum hugepages size.
155 int64 freepages_; // How many invalid pages we need.
156 int disk_pages_; // Number of pages per temp file.
157 uint64 paddr_base_; // Physical address base.
158 uint64 channel_hash_; // Mask of address bits XORed for channel.
159 int channel_width_; // Channel width in bits.
160 vector< vector<string> > channels_; // Memory module names per channel.
163 volatile sig_atomic_t user_break_; // User has signalled early exit. Used as
165 int verbosity_; // How much to print.
166 int print_delay_; // Chatty update frequency.
167 int strict_; // Check results per transaction.
168 int warm_; // FPU warms CPU while copying.
169 int address_mode_; // 32 or 64 bit binary.
170 bool stop_on_error_; // Exit immendiately on any error.
171 bool findfiles_; // Autodetect tempfile locations.
173 bool error_injection_; // Simulate errors, for unittests.
174 bool crazy_error_injection_; // Simulate lots of errors.
175 uint64 max_errorcount_; // Number of errors before forced exit.
176 int run_on_anything_; // Ignore unknown machine ereor.
177 int use_logfile_; // Log to a file.
178 char logfilename_[255]; // Name of file to log to.
179 int logfile_; // File handle to log to.
180 bool log_timestamps_; // Whether to add timestamps to log lines.
182 // Disk thread options.
183 int read_block_size_; // Size of block to read from disk.
184 int write_block_size_; // Size of block to write to disk.
185 int64 segment_size_; // Size of segment to split disk into.
186 int cache_size_; // Size of disk cache.
187 int blocks_per_segment_; // Number of blocks to test per segment.
188 int read_threshold_; // Maximum time (in us) a read should take
189 // before warning of a slow read.
190 int write_threshold_; // Maximum time (in us) a write should
191 // take before warning of a slow write.
192 int non_destructive_; // Whether to use non-destructive mode for
196 int monitor_mode_; // Switch for monitor-only mode SAT.
197 // This switch trumps most of the other
198 // argument, as SAT will only run error
200 int tag_mode_; // Do tagging of memory and strict
201 // checking for misplaced cachelines.
203 bool do_page_map_; // Should we print a list of used pages?
204 unsigned char *page_bitmap_; // Store bitmap of physical pages seen.
205 uint64 page_bitmap_size_; // Length of physical memory represented.
207 // Cpu Cache Coherency Options.
208 bool cc_test_; // Flag to decide whether to start the
209 // cache coherency threads.
210 int cc_cacheline_count_; // Number of cache line size structures.
211 int cc_cacheline_size_; // Size of a cache line.
212 int cc_inc_count_; // Number of times to increment the shared
213 // cache lines structure members.
215 // Cpu Frequency Options.
216 bool cpu_freq_test_; // Flag to decide whether to start the
217 // cpu frequency thread.
218 int cpu_freq_threshold_; // The MHz threshold which will cause
220 int cpu_freq_round_; // Round the computed frequency to this
224 int file_threads_; // Threads of file IO.
225 int net_threads_; // Threads of network IO.
226 int listen_threads_; // Threads for network IO to connect.
227 int memory_threads_; // Threads of memcpy.
228 int invert_threads_; // Threads of invert.
229 int fill_threads_; // Threads of memset.
230 int check_threads_; // Threads of strcmp.
231 int cpu_stress_threads_; // Threads of CPU stress workload.
232 int disk_threads_; // Threads of disk test.
233 int random_threads_; // Number of random disk threads.
234 int total_threads_; // Total threads used.
235 bool error_poll_; // Poll for system errors.
238 cc_cacheline_data *cc_cacheline_data_; // The cache line sized datastructure
239 // used by the ccache threads
241 vector<string> filename_; // Filenames for file IO.
242 vector<string> ipaddrs_; // Addresses for network IO.
243 vector<string> diskfilename_; // Filename for disk IO device.
244 // Block table for IO device.
245 vector<DiskBlockTable*> blocktables_;
247 int32 region_mask_; // Bitmask of available NUMA regions.
248 int32 region_count_; // Count of available NUMA regions.
249 int32 region_[32]; // Pagecount per region.
250 int region_mode_; // What to do with NUMA hints?
251 static const int kLocalNuma = 1; // Target local memory.
252 static const int kRemoteNuma = 2; // Target remote memory.
255 int64 errorcount_; // Total hardware incidents seen.
256 int statuscount_; // Total test errors seen.
258 // Thread type constants and types
275 virtual void AcquireWorkerLock();
276 virtual void ReleaseWorkerLock();
277 pthread_mutex_t worker_lock_; // Lock access to the worker thread structure.
278 typedef vector<WorkerThread*> WorkerVector;
279 typedef map<int, WorkerVector*> WorkerMap;
280 // Contains all worker threads.
281 WorkerMap workers_map_;
282 // Delay between power spikes.
284 // The duration of each pause (for power spikes).
285 time_t pause_duration_;
286 // For the workers we pause and resume to create power spikes.
287 WorkerStatus power_spike_status_;
288 // For the workers we never pause.
289 WorkerStatus continuous_status_;
291 class OsLayer *os_; // Os abstraction: put hacks here.
292 class PatternList *patternlist_; // Access to global data patterns.
294 // RunAnalysis methods
295 void AnalysisAllStats(); // Summary of all runs.
305 // Physical page use reporting.
307 void AddrMapUpdate(struct page_entry *pe);
310 // additional memory data from google-specific tests.
311 virtual void GoogleMemoryStats(float *memcopy_data,
312 float *memcopy_bandwidth);
314 virtual void GoogleOsOptions(std::map<std::string, std::string> *options);
316 // Page queues, only one of (valid_+empty_) or (finelock_q_) will be used
317 // at a time. A commandline switch controls which queue implementation will
319 class PageEntryQueue *valid_; // Page queue structure, valid pages.
320 class PageEntryQueue *empty_; // Page queue structure, free pages.
321 class FineLockPEQueue *finelock_q_; // Page queue with fine-grain locks
322 Sat::PageQueueType pe_q_implementation_; // Queue implementation switch
324 DISALLOW_COPY_AND_ASSIGN(Sat);
329 #endif // STRESSAPPTEST_SAT_H_