// Copyright 2006 Google Inc. All Rights Reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// worker.h : worker thread interface
// This file contains the Worker Thread class interface
// for the SAT test. Worker Threads implement a repetative
// task used to test or stress the system.
#ifndef STRESSAPPTEST_WORKER_H_
#define STRESSAPPTEST_WORKER_H_
#include <pthread.h>
#include <sys/time.h>
#include <sys/types.h>
#ifdef HAVE_LIBAIO_H
#include <libaio.h>
#endif
#include <queue>
#include <set>
#include <string>
#include <vector>
// This file must work with autoconf on its public version,
// so these includes are correct.
#include "disk_blocks.h"
#include "queue.h"
#include "sattypes.h"
// Global Datastruture shared by the Cache Coherency Worker Threads.
struct cc_cacheline_data {
char *num;
};
// Typical usage:
// (Other workflows may be possible, see function comments for details.)
// - Control thread creates object.
// - Control thread calls AddWorkers(1) for each worker thread.
// - Control thread calls Initialize().
// - Control thread launches worker threads.
// - Every worker thread frequently calls ContinueRunning().
// - Control thread periodically calls PauseWorkers(), effectively sleeps, and
// then calls ResumeWorkers().
// - Some worker threads may exit early, before StopWorkers() is called. They
// call RemoveSelf() after their last call to ContinueRunning().
// - Control thread eventually calls StopWorkers().
// - Worker threads exit.
// - Control thread joins worker threads.
// - Control thread calls Destroy().
// - Control thread destroys object.
//
// Threadsafety:
// - ContinueRunning() may be called concurrently by different workers, but not
// by a single worker.
// - No other methods may ever be called concurrently, with themselves or
// eachother.
// - This object may be used by multiple threads only between Initialize() and
// Destroy().
//
// TODO(matthewb): Move this class and its unittest to their own files.
class WorkerStatus {
public:
//--------------------------------
// Methods for the control thread.
//--------------------------------
WorkerStatus() : num_workers_(0), status_(RUN) {}
// Called by the control thread to increase the worker count. Must be called
// before Initialize(). The worker count is 0 upon object initialization.
void AddWorkers(int num_new_workers) {
// No need to lock num_workers_mutex_ because this is before Initialize().
num_workers_ += num_new_workers;
}
// Called by the control thread. May not be called multiple times. If
// called, Destroy() must be called before destruction.
void Initialize();
// Called by the control thread after joining all worker threads. Must be
// called iff Initialize() was called. No methods may be called after calling
// this.
void Destroy();
// Called by the control thread to tell the workers to pause. Does not return
// until all workers have called ContinueRunning() or RemoveSelf(). May only
// be called between Initialize() and Stop(). Must not be called multiple
// times without ResumeWorkers() having been called inbetween.
void PauseWorkers();
// Called by the control thread to tell the workers to resume from a pause.
// May only be called between Initialize() and Stop(). May only be called
// directly after PauseWorkers().
void ResumeWorkers();
// Called by the control thread to tell the workers to stop. May only be
// called between Initialize() and Destroy(). May only be called once.
void StopWorkers();
//--------------------------------
// Methods for the worker threads.
//--------------------------------
// Called by worker threads to decrease the worker count by one. May only be
// called between Initialize() and Destroy(). May wait for ResumeWorkers()
// when called after PauseWorkers().
void RemoveSelf();
// Called by worker threads between Initialize() and Destroy(). May be called
// any number of times. Return value is whether or not the worker should
// continue running. When called after PauseWorkers(), does not return until
// ResumeWorkers() or StopWorkers() has been called. Number of distinct
// calling threads must match the worker count (see AddWorkers() and
// RemoveSelf()).
bool ContinueRunning(bool *paused);
// This is a hack! It's like ContinueRunning(), except it won't pause. If
// any worker threads use this exclusively in place of ContinueRunning() then
// PauseWorkers() should never be used!
bool ContinueRunningNoPause();
private:
enum Status { RUN, PAUSE, STOP };
void WaitOnPauseBarrier() {
#ifdef HAVE_PTHREAD_BARRIERS
int error = pthread_barrier_wait(&pause_barrier_);
if (error != PTHREAD_BARRIER_SERIAL_THREAD)
sat_assert(error == 0);
#endif
}
void AcquireNumWorkersLock() {
sat_assert(0 == pthread_mutex_lock(&num_workers_mutex_));
}
void ReleaseNumWorkersLock() {
sat_assert(0 == pthread_mutex_unlock(&num_workers_mutex_));
}
void AcquireStatusReadLock() {
sat_assert(0 == pthread_rwlock_rdlock(&status_rwlock_));
}
void AcquireStatusWriteLock() {
sat_assert(0 == pthread_rwlock_wrlock(&status_rwlock_));
}
void ReleaseStatusLock() {
sat_assert(0 == pthread_rwlock_unlock(&status_rwlock_));
}
Status GetStatus() {
AcquireStatusReadLock();
Status status = status_;
ReleaseStatusLock();
return status;
}
// Returns the previous status.
Status SetStatus(Status status) {
AcquireStatusWriteLock();
Status prev_status = status_;
status_ = status;
ReleaseStatusLock();
return prev_status;
}
pthread_mutex_t num_workers_mutex_;
int num_workers_;
pthread_rwlock_t status_rwlock_;
Status status_;
#ifdef HAVE_PTHREAD_BARRIERS
// Guaranteed to not be in use when (status_ != PAUSE).
pthread_barrier_t pause_barrier_;
#endif
DISALLOW_COPY_AND_ASSIGN(WorkerStatus);
};
// This is a base class for worker threads.
// Each thread repeats a specific
// task on various blocks of memory.
class WorkerThread {
public:
// Enum to mark a thread as low/med/high priority.
enum Priority {
Low,
Normal,
High,
};
WorkerThread();
virtual ~WorkerThread();
// Initialize values and thread ID number.
virtual void InitThread(int thread_num_init,
class Sat *sat_init,
class OsLayer *os_init,
class PatternList *patternlist_init,
WorkerStatus *worker_status);
// This function is DEPRECATED, it does nothing.
void SetPriority(Priority priority) { priority_ = priority; }
// Spawn the worker thread, by running Work().
int SpawnThread();
// Only for ThreadSpawnerGeneric().
void StartRoutine();
bool InitPriority();
// Wait for the thread to complete its cleanup.
virtual bool JoinThread();
// Kill worker thread with SIGINT.
virtual bool KillThread();
// This is the task function that the thread executes.
// This is implemented per subclass.
virtual bool Work();
// Starts per-WorkerThread timer.
void StartThreadTimer() {gettimeofday(&start_time_, NULL);}
// Reads current timer value and returns run duration without recording it.
int64 ReadThreadTimer() {
struct timeval end_time_;
gettimeofday(&end_time_, NULL);
return (end_time_.tv_sec - start_time_.tv_sec)*1000000ULL +
(end_time_.tv_usec - start_time_.tv_usec);
}
// Stops per-WorkerThread timer and records thread run duration.
// Start/Stop ThreadTimer repetitively has cumulative effect, ie the timer
// is effectively paused and restarted, so runduration_usec accumulates on.
void StopThreadTimer() {
runduration_usec_ += ReadThreadTimer();
}
// Acccess member variables.
bool GetStatus() {return status_;}
int64 GetErrorCount() {return errorcount_;}
int64 GetPageCount() {return pages_copied_;}
int64 GetRunDurationUSec() {return runduration_usec_;}
// Returns bandwidth defined as pages_copied / thread_run_durations.
virtual float GetCopiedData();
// Calculate worker thread specific copied data.
virtual float GetMemoryCopiedData() {return 0;}
virtual float GetDeviceCopiedData() {return 0;}
// Calculate worker thread specific bandwidth.
virtual float GetMemoryBandwidth()
{return GetMemoryCopiedData() / (
runduration_usec_ * 1.0 / 1000000.);}
virtual float GetDeviceBandwidth()
{return GetDeviceCopiedData() / (
runduration_usec_ * 1.0 / 1000000.);}
void set_cpu_mask(cpu_set_t *mask) {
memcpy(&cpu_mask_, mask, sizeof(*mask));
}
void set_cpu_mask_to_cpu(int cpu_num) {
cpuset_set_ab(&cpu_mask_, cpu_num, cpu_num + 1);
}
void set_tag(int32 tag) {tag_ = tag;}
// Returns CPU mask, where each bit represents a logical cpu.
bool AvailableCpus(cpu_set_t *cpuset);
// Returns CPU mask of CPUs this thread is bound to,
bool CurrentCpus(cpu_set_t *cpuset);
// Returns Current Cpus mask as string.
string CurrentCpusFormat() {
cpu_set_t current_cpus;
CurrentCpus(¤t_cpus);
return cpuset_format(¤t_cpus);
}
int ThreadID() {return thread_num_;}
// Bind worker thread to specified CPU(s)
bool BindToCpus(const cpu_set_t *cpuset);
protected:
// This function dictates whether the main work loop
// continues, waits, or terminates.
// All work loops should be of the form:
// do {
// // work.
// } while (IsReadyToRun());
virtual bool IsReadyToRun(bool *paused = NULL) {
return worker_status_->ContinueRunning(paused);
}
// Like IsReadyToRun(), except it won't pause.
virtual bool IsReadyToRunNoPause() {
return worker_status_->ContinueRunningNoPause();
}
// These are functions used by the various work loops.
// Pretty print and log a data miscompare.
virtual void ProcessError(struct ErrorRecord *er,
int priority,
const char *message);
// Compare a region of memory with a known data patter, and report errors.
virtual int CheckRegion(void *addr,
class Pattern *pat,
int64 length,
int offset,
int64 patternoffset);
// Fast compare a block of memory.
virtual int CrcCheckPage(struct page_entry *srcpe);
// Fast copy a block of memory, while verifying correctness.
virtual int CrcCopyPage(struct page_entry *dstpe,
struct page_entry *srcpe);
// Fast copy a block of memory, while verifying correctness, and heating CPU.
virtual int CrcWarmCopyPage(struct page_entry *dstpe,
struct page_entry *srcpe);
// Fill a page with its specified pattern.
virtual bool FillPage(struct page_entry *pe);
// Copy with address tagging.
virtual bool AdlerAddrMemcpyC(uint64 *dstmem64,
uint64 *srcmem64,
unsigned int size_in_bytes,
AdlerChecksum *checksum,
struct page_entry *pe);
// SSE copy with address tagging.
virtual bool AdlerAddrMemcpyWarm(uint64 *dstmem64,
uint64 *srcmem64,
unsigned int size_in_bytes,
AdlerChecksum *checksum,
struct page_entry *pe);
// Crc data with address tagging.
virtual bool AdlerAddrCrcC(uint64 *srcmem64,
unsigned int size_in_bytes,
AdlerChecksum *checksum,
struct page_entry *pe);
// Setup tagging on an existing page.
virtual bool TagAddrC(uint64 *memwords,
unsigned int size_in_bytes);
// Report a mistagged cacheline.
virtual bool ReportTagError(uint64 *mem64,
uint64 actual,
uint64 tag);
// Print out the error record of the tag mismatch.
virtual void ProcessTagError(struct ErrorRecord *error,
int priority,
const char *message);
// A worker thread can yield itself to give up CPU until it's scheduled again
bool YieldSelf();
protected:
// General state variables that all subclasses need.
int thread_num_; // Thread ID.
volatile bool status_; // Error status.
volatile int64 pages_copied_; // Recorded for memory bandwidth calc.
volatile int64 errorcount_; // Miscompares seen by this thread.
cpu_set_t cpu_mask_; // Cores this thread is allowed to run on.
volatile uint32 tag_; // Tag hint for memory this thread can use.
bool tag_mode_; // Tag cachelines with vaddr.
// Thread timing variables.
struct timeval start_time_; // Worker thread start time.
volatile int64 runduration_usec_; // Worker run duration in u-seconds.
// Function passed to pthread_create.
void *(*thread_spawner_)(void *args);
pthread_t thread_; // Pthread thread ID.
Priority priority_; // Worker thread priority.
class Sat *sat_; // Reference to parent stest object.
class OsLayer *os_; // Os abstraction: put hacks here.
class PatternList *patternlist_; // Reference to data patterns.
// Work around style guide ban on sizeof(int).
static const uint64 iamint_ = 0;
static const int wordsize_ = sizeof(iamint_);
private:
WorkerStatus *worker_status_;
DISALLOW_COPY_AND_ASSIGN(WorkerThread);
};
// Worker thread to perform File IO.
class FileThread : public WorkerThread {
public:
FileThread();
// Set filename to use for file IO.
virtual void SetFile(const char *filename_init);
virtual bool Work();
// Calculate worker thread specific bandwidth.
virtual float GetDeviceCopiedData()
{return GetCopiedData()*2;}
virtual float GetMemoryCopiedData();
protected:
// Record of where these pages were sourced from, and what
// potentially broken components they passed through.
struct PageRec {
class Pattern *pattern; // This is the data it should contain.
void *src; // This is the memory location the data was sourced from.
void *dst; // This is where it ended up.
};
// These are functions used by the various work loops.
// Pretty print and log a data miscompare. Disks require
// slightly different error handling.
virtual void ProcessError(struct ErrorRecord *er,
int priority,
const char *message);
virtual bool OpenFile(int *pfile);
virtual bool CloseFile(int fd);
// Read and write whole file to disk.
virtual bool WritePages(int fd);
virtual bool ReadPages(int fd);
// Read and write pages to disk.
virtual bool WritePageToFile(int fd, struct page_entry *src);
virtual bool ReadPageFromFile(int fd, struct page_entry *dst);
// Sector tagging support.
virtual bool SectorTagPage(struct page_entry *src, int block);
virtual bool SectorValidatePage(const struct PageRec &page,
struct page_entry *dst,
int block);
// Get memory for an incoming data transfer..
virtual bool PagePrepare();
// Remove memory allocated for data transfer.
virtual bool PageTeardown();
// Get memory for an incoming data transfer..
virtual bool GetEmptyPage(struct page_entry *dst);
// Get memory for an outgoing data transfer..
virtual bool GetValidPage(struct page_entry *dst);
// Throw out a used empty page.
virtual bool PutEmptyPage(struct page_entry *src);
// Throw out a used, filled page.
virtual bool PutValidPage(struct page_entry *src);
struct PageRec *page_recs_; // Array of page records.
int crc_page_; // Page currently being CRC checked.
string filename_; // Name of file to access.
string devicename_; // Name of device file is on.
bool page_io_; // Use page pool for IO.
void *local_page_; // malloc'd page fon non-pool IO.
int pass_; // Number of writes to the file so far.
// Tag to detect file corruption.
struct SectorTag {
volatile uint8 magic;
volatile uint8 block;
volatile uint8 sector;
volatile uint8 pass;
char pad[512-4];
};
DISALLOW_COPY_AND_ASSIGN(FileThread);
};
// Worker thread to perform Network IO.
class NetworkThread : public WorkerThread {
public:
NetworkThread();
// Set hostname to use for net IO.
virtual void SetIP(const char *ipaddr_init);
virtual bool Work();
// Calculate worker thread specific bandwidth.
virtual float GetDeviceCopiedData()
{return GetCopiedData()*2;}
protected:
// IsReadyToRunNoPause() wrapper, for NetworkSlaveThread to override.
virtual bool IsNetworkStopSet();
virtual bool CreateSocket(int *psocket);
virtual bool CloseSocket(int sock);
virtual bool Connect(int sock);
virtual bool SendPage(int sock, struct page_entry *src);
virtual bool ReceivePage(int sock, struct page_entry *dst);
char ipaddr_[256];
int sock_;
private:
DISALLOW_COPY_AND_ASSIGN(NetworkThread);
};
// Worker thread to reflect Network IO.
class NetworkSlaveThread : public NetworkThread {
public:
NetworkSlaveThread();
// Set socket for IO.
virtual void SetSock(int sock);
virtual bool Work();
protected:
virtual bool IsNetworkStopSet();
private:
DISALLOW_COPY_AND_ASSIGN(NetworkSlaveThread);
};
// Worker thread to detect incoming Network IO.
class NetworkListenThread : public NetworkThread {
public:
NetworkListenThread();
virtual bool Work();
private:
virtual bool Listen();
virtual bool Wait();
virtual bool GetConnection(int *pnewsock);
virtual bool SpawnSlave(int newsock, int threadid);
virtual bool ReapSlaves();
// For serviced incoming connections.
struct ChildWorker {
WorkerStatus status;
NetworkSlaveThread thread;
};
typedef vector<ChildWorker*> ChildVector;
ChildVector child_workers_;
DISALLOW_COPY_AND_ASSIGN(NetworkListenThread);
};
// Worker thread to perform Memory Copy.
class CopyThread : public WorkerThread {
public:
CopyThread() {}
virtual bool Work();
// Calculate worker thread specific bandwidth.
virtual float GetMemoryCopiedData()
{return GetCopiedData()*2;}
private:
DISALLOW_COPY_AND_ASSIGN(CopyThread);
};
// Worker thread to perform Memory Invert.
class InvertThread : public WorkerThread {
public:
InvertThread() {}
virtual bool Work();
// Calculate worker thread specific bandwidth.
virtual float GetMemoryCopiedData()
{return GetCopiedData()*4;}
private:
virtual int InvertPageUp(struct page_entry *srcpe);
virtual int InvertPageDown(struct page_entry *srcpe);
DISALLOW_COPY_AND_ASSIGN(InvertThread);
};
// Worker thread to fill blank pages on startup.
class FillThread : public WorkerThread {
public:
FillThread();
// Set how many pages this thread should fill before exiting.
virtual void SetFillPages(int64 num_pages_to_fill_init);
virtual bool Work();
private:
// Fill a page with the data pattern in pe->pattern.
virtual bool FillPageRandom(struct page_entry *pe);
int64 num_pages_to_fill_;
DISALLOW_COPY_AND_ASSIGN(FillThread);
};
// Worker thread to verify page data matches pattern data.
// Thread will check and replace pages until "done" flag is set,
// then it will check and discard pages until no more remain.
class CheckThread : public WorkerThread {
public:
CheckThread() {}
virtual bool Work();
// Calculate worker thread specific bandwidth.
virtual float GetMemoryCopiedData()
{return GetCopiedData();}
private:
DISALLOW_COPY_AND_ASSIGN(CheckThread);
};
// Worker thread to poll for system error messages.
// Thread will check for messages until "done" flag is set.
class ErrorPollThread : public WorkerThread {
public:
ErrorPollThread() {}
virtual bool Work();
private:
DISALLOW_COPY_AND_ASSIGN(ErrorPollThread);
};
// Computation intensive worker thread to stress CPU.
class CpuStressThread : public WorkerThread {
public:
CpuStressThread() {}
virtual bool Work();
private:
DISALLOW_COPY_AND_ASSIGN(CpuStressThread);
};
// Worker thread that tests the correctness of the
// CPU Cache Coherency Protocol.
class CpuCacheCoherencyThread : public WorkerThread {
public:
CpuCacheCoherencyThread(cc_cacheline_data *cc_data,
int cc_cacheline_count_,
int cc_thread_num_,
int cc_thread_count_,
int cc_inc_count_);
virtual bool Work();
protected:
// Used by the simple random number generator as a shift feedback;
// this polynomial (x^64 + x^63 + x^61 + x^60 + 1) will produce a
// psuedorandom cycle of period 2^64-1.
static const uint64 kRandomPolynomial = 0xD800000000000000ULL;
// A very simple psuedorandom generator that can be inlined and use
// registers, to keep the CC test loop tight and focused.
static uint64 SimpleRandom(uint64 seed);
cc_cacheline_data *cc_cacheline_data_; // Datstructure for each cacheline.
int cc_local_num_; // Local counter for each thread.
int cc_cacheline_count_; // Number of cache lines to operate on.
int cc_thread_num_; // The integer id of the thread which is
// used as an index into the integer array
// of the cacheline datastructure.
int cc_thread_count_; // Total number of threads being run, for
// calculations mixing up cache line access.
int cc_inc_count_; // Number of times to increment the counter.
private:
DISALLOW_COPY_AND_ASSIGN(CpuCacheCoherencyThread);
};
// Worker thread to perform disk test.
class DiskThread : public WorkerThread {
public:
explicit DiskThread(DiskBlockTable *block_table);
virtual ~DiskThread();
// Calculate disk thread specific bandwidth.
virtual float GetDeviceCopiedData() {
return (blocks_written_ * write_block_size_ +
blocks_read_ * read_block_size_) / kMegabyte;}
// Set filename for device file (in /dev).
virtual void SetDevice(const char *device_name);
// Set various parameters that control the behaviour of the test.
virtual bool SetParameters(int read_block_size,
int write_block_size,
int64 segment_size,
int64 cache_size,
int blocks_per_segment,
int64 read_threshold,
int64 write_threshold,
int non_destructive);
virtual bool Work();
virtual float GetMemoryCopiedData() {return 0;}
protected:
static const int kSectorSize = 512; // Size of sector on disk.
static const int kBufferAlignment = 512; // Buffer alignment required by the
// kernel.
static const int kBlockRetry = 100; // Number of retries to allocate
// sectors.
enum IoOp {
ASYNC_IO_READ = 0,
ASYNC_IO_WRITE = 1
};
virtual bool OpenDevice(int *pfile);
virtual bool CloseDevice(int fd);
// Retrieves the size (in bytes) of the disk/file.
virtual bool GetDiskSize(int fd);
// Retrieves the current time in microseconds.
virtual int64 GetTime();
// Do an asynchronous disk I/O operation.
virtual bool AsyncDiskIO(IoOp op, int fd, void *buf, int64 size,
int64 offset, int64 timeout);
// Write a block to disk.
virtual bool WriteBlockToDisk(int fd, BlockData *block);
// Verify a block on disk.
virtual bool ValidateBlockOnDisk(int fd, BlockData *block);
// Main work loop.
virtual bool DoWork(int fd);
int read_block_size_; // Size of blocks read from disk, in bytes.
int write_block_size_; // Size of blocks written to disk, in bytes.
int64 blocks_read_; // Number of blocks read in work loop.
int64 blocks_written_; // Number of blocks written in work loop.
int64 segment_size_; // Size of disk segments (in bytes) that the disk
// will be split into where testing can be
// confined to a particular segment.
// Allows for control of how evenly the disk will
// be tested. Smaller segments imply more even
// testing (less random).
int blocks_per_segment_; // Number of blocks that will be tested per
// segment.
int cache_size_; // Size of disk cache, in bytes.
int queue_size_; // Length of in-flight-blocks queue, in blocks.
int non_destructive_; // Use non-destructive mode or not.
int update_block_table_; // If true, assume this is the thread
// responsible for writing the data in the disk
// for this block device and, therefore,
// update the block table. If false, just use
// the block table to get data.
// read/write times threshold for reporting a problem
int64 read_threshold_; // Maximum time a read should take (in us) before
// a warning is given.
int64 write_threshold_; // Maximum time a write should take (in us) before
// a warning is given.
int64 read_timeout_; // Maximum time a read can take before a timeout
// and the aborting of the read operation.
int64 write_timeout_; // Maximum time a write can take before a timeout
// and the aborting of the write operation.
string device_name_; // Name of device file to access.
int64 device_sectors_; // Number of sectors on the device.
std::queue<BlockData*> in_flight_sectors_; // Queue of sectors written but
// not verified.
void *block_buffer_; // Pointer to aligned block buffer.
#ifdef HAVE_LIBAIO_H
io_context_t aio_ctx_; // Asynchronous I/O context for Linux native AIO.
#endif
DiskBlockTable *block_table_; // Disk Block Table, shared by all disk
// threads that read / write at the same
// device
DISALLOW_COPY_AND_ASSIGN(DiskThread);
};
class RandomDiskThread : public DiskThread {
public:
explicit RandomDiskThread(DiskBlockTable *block_table);
virtual ~RandomDiskThread();
// Main work loop.
virtual bool DoWork(int fd);
protected:
DISALLOW_COPY_AND_ASSIGN(RandomDiskThread);
};
// Worker thread to perform checks in a specific memory region.
class MemoryRegionThread : public WorkerThread {
public:
MemoryRegionThread();
~MemoryRegionThread();
virtual bool Work();
void ProcessError(struct ErrorRecord *error, int priority,
const char *message);
bool SetRegion(void *region, int64 size);
// Calculate worker thread specific bandwidth.
virtual float GetMemoryCopiedData()
{return GetCopiedData();}
virtual float GetDeviceCopiedData()
{return GetCopiedData() * 2;}
void SetIdentifier(string identifier) {
identifier_ = identifier;
}
protected:
// Page queue for this particular memory region.
char *region_;
PageEntryQueue *pages_;
bool error_injection_;
int phase_;
string identifier_;
static const int kPhaseNoPhase = 0;
static const int kPhaseCopy = 1;
static const int kPhaseCheck = 2;
private:
DISALLOW_COPY_AND_ASSIGN(MemoryRegionThread);
};
// Worker thread to check that the frequency of every cpu does not go below a
// certain threshold.
class CpuFreqThread : public WorkerThread {
public:
CpuFreqThread(int num_cpus, int freq_threshold, int round);
~CpuFreqThread();
// This is the task function that the thread executes.
virtual bool Work();
// Returns true if this test can run on the current machine. Otherwise,
// returns false.
static bool CanRun();
private:
static const int kIntervalPause = 10; // The number of seconds to pause
// between acquiring the MSR data.
static const int kStartupDelay = 5; // The number of seconds to wait
// before acquiring MSR data.
static const int kMsrTscAddr = 0x10; // The address of the TSC MSR.
static const int kMsrAperfAddr = 0xE8; // The address of the APERF MSR.
static const int kMsrMperfAddr = 0xE7; // The address of the MPERF MSR.
// The index values into the CpuDataType.msr[] array.
enum MsrValues {
kMsrTsc = 0, // MSR index 0 = TSC.
kMsrAperf = 1, // MSR index 1 = APERF.
kMsrMperf = 2, // MSR index 2 = MPERF.
kMsrLast, // Last MSR index.
};
typedef struct {
uint32 msr; // The address of the MSR.
const char *name; // A human readable string for the MSR.
} CpuRegisterType;
typedef struct {
uint64 msrs[kMsrLast]; // The values of the MSRs.
struct timeval tv; // The time at which the MSRs were read.
} CpuDataType;
// The set of MSR addresses and register names.
static const CpuRegisterType kCpuRegisters[kMsrLast];
// Compute the change in values of the MSRs between current and previous,
// set the frequency in MHz of the cpu. If there is an error computing
// the delta, return false. Othewise, return true.
bool ComputeFrequency(CpuDataType *current, CpuDataType *previous,
int *frequency);
// Get the MSR values for this particular cpu and save them in data. If
// any error is encountered, returns false. Otherwise, returns true.
bool GetMsrs(int cpu, CpuDataType *data);
// Compute the difference between the currently read MSR values and the
// previously read values and store the results in delta. If any of the
// values did not increase, or the TSC value is too small, returns false.
// Otherwise, returns true.
bool ComputeDelta(CpuDataType *current, CpuDataType *previous,
CpuDataType *delta);
// The total number of cpus on the system.
int num_cpus_;
// The minimum frequency that each cpu must operate at (in MHz).
int freq_threshold_;
// The value to round the computed frequency to.
int round_;
// Precomputed value to add to the frequency to do the rounding.
double round_value_;
DISALLOW_COPY_AND_ASSIGN(CpuFreqThread);
};
#endif // STRESSAPPTEST_WORKER_H_