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.
138 // Collect error counts from threads.
139 int64 GetTotalErrorCount();
141 // Command line arguments.
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 freepages_; // How many invalid pages we need.
151 int disk_pages_; // Number of pages per temp file.
152 uint64 paddr_base_; // Physical address base.
155 volatile sig_atomic_t user_break_; // User has signalled early exit. Used as
157 int verbosity_; // How much to print.
158 int strict_; // Check results per transaction.
159 int warm_; // FPU warms CPU while coying.
160 int address_mode_; // 32 or 64 bit binary.
161 bool stop_on_error_; // Exit immendiately on any error.
162 bool findfiles_; // Autodetect tempfile locations.
164 bool error_injection_; // Simulate errors, for unittests.
165 bool crazy_error_injection_; // Simulate lots of errors.
166 int64 max_errorcount_; // Number of errors before forced exit.
167 int run_on_anything_; // Ignore unknown machine ereor.
168 int use_logfile_; // Log to a file.
169 char logfilename_[255]; // Name of file to log to.
170 int logfile_; // File handle to log to.
172 // Disk thread options.
173 int read_block_size_; // Size of block to read from disk.
174 int write_block_size_; // Size of block to write to disk.
175 int64 segment_size_; // Size of segment to split disk into.
176 int cache_size_; // Size of disk cache.
177 int blocks_per_segment_; // Number of blocks to test per segment.
178 int read_threshold_; // Maximum time (in us) a read should take
179 // before warning of a slow read.
180 int write_threshold_; // Maximum time (in us) a write should
181 // take before warning of a slow write.
182 int non_destructive_; // Whether to use non-destructive mode for
186 int monitor_mode_; // Switch for monitor-only mode SAT.
187 // This switch trumps most of the other
188 // argument, as SAT will only run error
190 int tag_mode_; // Do tagging of memory and strict
191 // checking for misplaced cachelines.
193 bool do_page_map_; // Should we print a list of used pages?
194 unsigned char *page_bitmap_; // Store bitmap of physical pages seen.
195 uint64 page_bitmap_size_; // Length of physical memory represented.
197 // Cpu Cache Coherency Options.
198 bool cc_test_; // Flag to decide whether to start the
199 // cache coherency threads.
200 int cc_cacheline_count_; // Number of cache line size structures.
201 int cc_inc_count_; // Number of times to increment the shared
202 // cache lines structure members.
205 int file_threads_; // Threads of file IO.
206 int net_threads_; // Threads of network IO.
207 int listen_threads_; // Threads for network IO to connect.
208 int memory_threads_; // Threads of memcpy.
209 int invert_threads_; // Threads of invert.
210 int fill_threads_; // Threads of memset.
211 int check_threads_; // Threads of strcmp.
212 int cpu_stress_threads_; // Threads of CPU stress workload.
213 int disk_threads_; // Threads of disk test.
214 int random_threads_; // Number of random disk threads.
215 int total_threads_; // Total threads used.
216 bool error_poll_; // Poll for system errors.
219 cc_cacheline_data *cc_cacheline_data_; // The cache line sized datastructure
220 // used by the ccache threads
222 vector<string> filename_; // Filenames for file IO.
223 vector<string> ipaddrs_; // Addresses for network IO.
224 vector<string> diskfilename_; // Filename for disk IO device.
225 // Block table for IO device.
226 vector<DiskBlockTable*> blocktables_;
228 int32 region_mask_; // Bitmask of available NUMA regions.
229 int32 region_count_; // Count of available NUMA regions.
230 int32 region_[32]; // Pagecount per region.
231 int region_mode_; // What to do with NUMA hints?
232 static const int kLocalNuma = 1; // Target local memory.
233 static const int kRemoteNuma = 2; // Target remote memory.
236 int64 errorcount_; // Total hardware incidents seen.
237 int statuscount_; // Total test errors seen.
239 // Thread type constants and types
255 virtual void AcquireWorkerLock();
256 virtual void ReleaseWorkerLock();
257 pthread_mutex_t worker_lock_; // Lock access to the worker thread structure.
258 typedef vector<WorkerThread*> WorkerVector;
259 typedef map<int, WorkerVector*> WorkerMap;
260 // Contains all worker threads.
261 WorkerMap workers_map_;
262 // Delay between power spikes.
264 // The duration of each pause (for power spikes).
265 time_t pause_duration_;
266 // For the workers we pause and resume to create power spikes.
267 WorkerStatus power_spike_status_;
268 // For the workers we never pause.
269 WorkerStatus continuous_status_;
271 class OsLayer *os_; // Os abstraction: put hacks here.
272 class PatternList *patternlist_; // Access to global data patterns.
274 // RunAnalysis methods
275 void AnalysisAllStats(); // Summary of all runs.
285 // Physical page use reporting.
287 void AddrMapUpdate(struct page_entry *pe);
290 // additional memory data from google-specific tests.
291 virtual void GoogleMemoryStats(float *memcopy_data,
292 float *memcopy_bandwidth);
294 virtual void GoogleOsOptions(std::map<std::string, std::string> *options);
296 // Page queues, only one of (valid_+empty_) or (finelock_q_) will be used
297 // at a time. A commandline switch controls which queue implementation will
299 class PageEntryQueue *valid_; // Page queue structure, valid pages.
300 class PageEntryQueue *empty_; // Page queue structure, free pages.
301 class FineLockPEQueue *finelock_q_; // Page queue with fine-grain locks
302 Sat::PageQueueType pe_q_implementation_; // Queue implementation switch
304 DISALLOW_COPY_AND_ASSIGN(Sat);
309 #endif // STRESSAPPTEST_SAT_H_