721 lines
18 KiB
C++
721 lines
18 KiB
C++
// StresDlg.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "CpuStres.h"
|
|
#include "StresDlg.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAboutDlg dialog used for App About
|
|
|
|
class CAboutDlg : public CDialog
|
|
{
|
|
public:
|
|
CAboutDlg();
|
|
|
|
// Dialog Data
|
|
//{{AFX_DATA(CAboutDlg)
|
|
enum { IDD = IDD_ABOUTBOX };
|
|
//}}AFX_DATA
|
|
|
|
// ClassWizard generated virtual function overrides
|
|
//{{AFX_VIRTUAL(CAboutDlg)
|
|
protected:
|
|
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
|
|
//}}AFX_VIRTUAL
|
|
|
|
// Implementation
|
|
protected:
|
|
//{{AFX_MSG(CAboutDlg)
|
|
//}}AFX_MSG
|
|
DECLARE_MESSAGE_MAP()
|
|
};
|
|
|
|
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CAboutDlg)
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CAboutDlg)
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CAboutDlg)
|
|
// No message handlers
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CStressDlg dialog
|
|
|
|
CStressDlg::CStressDlg(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CStressDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CStressDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
|
|
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
|
|
m_dwProcessPriority = NORMAL_PRIORITY_CLASS;
|
|
|
|
m_ActivityValue[0] = SLOW_ACTIVITY;
|
|
m_ActivityValue[1] = SLOW_ACTIVITY;
|
|
m_ActivityValue[2] = SLOW_ACTIVITY;
|
|
m_ActivityValue[3] = SLOW_ACTIVITY;
|
|
|
|
m_PriorityValue[0] = THREAD_PRIORITY_NORMAL;
|
|
m_PriorityValue[1] = THREAD_PRIORITY_NORMAL;
|
|
m_PriorityValue[2] = THREAD_PRIORITY_NORMAL;
|
|
m_PriorityValue[3] = THREAD_PRIORITY_NORMAL;
|
|
|
|
m_Active[0] = TRUE;
|
|
m_Active[1] = FALSE;
|
|
m_Active[2] = FALSE;
|
|
m_Active[3] = FALSE;
|
|
|
|
m_ThreadHandle[0] = NULL;
|
|
m_ThreadHandle[1] = NULL;
|
|
m_ThreadHandle[2] = NULL;
|
|
m_ThreadHandle[3] = NULL;
|
|
|
|
m_dwLoopValue = 0x00010000;
|
|
|
|
m_pMemory = NULL;
|
|
m_dwVASize = 0;
|
|
m_dwRandomScale = 1;
|
|
}
|
|
|
|
void CStressDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CStressDlg)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CStressDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CStressDlg)
|
|
ON_WM_SYSCOMMAND()
|
|
ON_WM_PAINT()
|
|
ON_WM_QUERYDRAGICON()
|
|
ON_BN_CLICKED(IDC_1_ACTIVE, On1Active)
|
|
ON_CBN_SELCHANGE(IDC_1_ACTIVITY, OnSelchange1Activity)
|
|
ON_CBN_SELCHANGE(IDC_1_PRIORITY, OnSelchange1Priority)
|
|
ON_BN_CLICKED(IDC_2_ACTIVE, On2Active)
|
|
ON_CBN_SELCHANGE(IDC_2_ACTIVITY, OnSelchange2Activity)
|
|
ON_CBN_SELCHANGE(IDC_2_PRIORITY, OnSelchange2Priority)
|
|
ON_BN_CLICKED(IDC_3_ACTIVE, On3Active)
|
|
ON_CBN_SELCHANGE(IDC_3_ACTIVITY, OnSelchange3Activity)
|
|
ON_CBN_SELCHANGE(IDC_3_PRIORITY, OnSelchange3Priority)
|
|
ON_BN_CLICKED(IDC_4_ACTIVE, On4Active)
|
|
ON_CBN_SELCHANGE(IDC_4_ACTIVITY, OnSelchange4Activity)
|
|
ON_CBN_SELCHANGE(IDC_4_PRIORITY, OnSelchange4Priority)
|
|
ON_CBN_SELCHANGE(IDC_PROCESS_PRIORITY, OnSelchangeProcessPriority)
|
|
ON_EN_KILLFOCUS(IDC_SHARED_MEM_SIZE, OnKillfocusSharedMemSize)
|
|
ON_EN_CHANGE(IDC_SHARED_MEM_SIZE, OnChangeSharedMemSize)
|
|
ON_BN_CLICKED(IDC_USE_MEMORY, OnUseMemory)
|
|
ON_WM_CLOSE()
|
|
ON_WM_DESTROY()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
// disable optimization since it will remove the "do-nothing" loops
|
|
#pragma optimize ("", off)
|
|
DWORD CStressDlg::OnePercentCalibration(DWORD dwLoopValue)
|
|
{
|
|
// find how many loops consume 10% of this processor
|
|
LARGE_INTEGER liPerfFreq;
|
|
LONGLONG llOnePercent;
|
|
LARGE_INTEGER liStartTime;
|
|
LARGE_INTEGER liEndTime;
|
|
LONGLONG llDiff;
|
|
LONGLONG llMinDiff;
|
|
DWORD dwPriorityClass;
|
|
DWORD dwThreadPriority;
|
|
HANDLE hProcess;
|
|
HANDLE hThread;
|
|
DWORD dwLoopCounter;
|
|
DWORD dwReturn;
|
|
LONGLONG llResult;
|
|
BOOL bGoodSample = FALSE;
|
|
DWORD dwAttemptCount = 5;
|
|
|
|
dwReturn = dwLoopValue;
|
|
QueryPerformanceFrequency (&liPerfFreq);
|
|
llOnePercent = liPerfFreq.QuadPart / 100;
|
|
// the calibration run must take at least 50 ms
|
|
llMinDiff = liPerfFreq.QuadPart / 20;
|
|
|
|
hProcess = GetCurrentProcess();
|
|
hThread = GetCurrentThread();
|
|
dwPriorityClass = GetPriorityClass (hProcess);
|
|
dwThreadPriority = GetThreadPriority (hThread);
|
|
|
|
SetPriorityClass (hProcess, HIGH_PRIORITY_CLASS);
|
|
SetThreadPriority (hThread, THREAD_PRIORITY_HIGHEST);
|
|
|
|
while (!bGoodSample && dwAttemptCount) {
|
|
// start timing
|
|
QueryPerformanceCounter (&liStartTime);
|
|
// do a trial loop
|
|
for (dwLoopCounter = dwLoopValue; dwLoopCounter; dwLoopCounter--);
|
|
// end timing
|
|
QueryPerformanceCounter (&liEndTime);
|
|
llDiff = liEndTime.QuadPart - liStartTime.QuadPart;
|
|
if (llDiff > llMinDiff) {
|
|
bGoodSample = TRUE;
|
|
} else {
|
|
// increase the loop counter value by a factor of 10
|
|
dwLoopValue *= 10;
|
|
dwAttemptCount--;
|
|
}
|
|
}
|
|
// restore the priority since we're done with the critical part
|
|
SetPriorityClass (hProcess, dwPriorityClass);
|
|
SetThreadPriority (hThread, dwThreadPriority);
|
|
|
|
if (!bGoodSample) {
|
|
MessageBox("Unable to calibrate delay loop");
|
|
} else {
|
|
// findout what the 1% count is
|
|
|
|
if (llDiff != llOnePercent) {
|
|
// then adjust the initial loop value was too big so reduce
|
|
llResult = llOnePercent * dwLoopValue / llDiff;
|
|
if (llResult & 0xFFFFFFFF00000000) {
|
|
// this processor is TOO FAST! so don't change.
|
|
} else {
|
|
dwReturn = (DWORD)(llResult & 0x00000000FFFFFFFF);
|
|
}
|
|
}
|
|
}
|
|
return dwReturn;
|
|
}
|
|
|
|
DWORD WorkerProc (LPDWORD dwArg)
|
|
{
|
|
DWORD dwLoopCounter;
|
|
LPTHREAD_INFO_BLOCK pInfo;
|
|
DWORD dwStartingValue;
|
|
DWORD dwLocalValue;
|
|
DWORD dwLocalIndex;
|
|
|
|
pInfo = (LPTHREAD_INFO_BLOCK)dwArg;
|
|
|
|
dwStartingValue = pInfo->Dlg->m_dwLoopValue;
|
|
|
|
srand( (unsigned)time( NULL ) );
|
|
|
|
while (pInfo->Dlg->m_Active[pInfo->dwId]) {
|
|
for (dwLoopCounter = dwStartingValue; dwLoopCounter; dwLoopCounter--) {
|
|
if (pInfo->Dlg->m_pMemory != NULL) {
|
|
do {
|
|
dwLocalIndex = rand();
|
|
dwLocalIndex *= pInfo->Dlg->m_dwRandomScale;
|
|
} while (dwLocalIndex >= pInfo->Dlg->m_dwVASize);
|
|
pInfo->Dlg->m_pMemory[dwLocalIndex] = dwLocalIndex;
|
|
dwLocalValue = pInfo->Dlg->m_pMemory[dwLocalIndex];
|
|
// reduce loop iterations to account for
|
|
// accessing memory
|
|
if (pInfo->Dlg->m_Active[pInfo->dwId]) {
|
|
if (dwLoopCounter > 20) {
|
|
dwLoopCounter -= 20;
|
|
} else {
|
|
dwLoopCounter = 1;
|
|
}
|
|
} else {
|
|
break; // out of loop
|
|
}
|
|
}
|
|
}
|
|
if (pInfo->Dlg->m_ActivityValue[pInfo->dwId] > 0) {
|
|
Sleep (pInfo->Dlg->m_ActivityValue[pInfo->dwId]);
|
|
}
|
|
}
|
|
pInfo->Dlg->m_ThreadHandle[pInfo->dwId] = NULL;
|
|
delete pInfo;
|
|
return 0;
|
|
}
|
|
#pragma optimize ("", on)
|
|
|
|
void CStressDlg::CreateWorkerThread (DWORD dwId)
|
|
{
|
|
DWORD dwThreadId;
|
|
LPTHREAD_INFO_BLOCK pInfo;
|
|
|
|
// then start a new thread
|
|
pInfo = new THREAD_INFO_BLOCK;
|
|
if (!pInfo) {
|
|
return;
|
|
}
|
|
pInfo->Dlg = this;
|
|
pInfo->dwId = dwId;
|
|
m_Active[dwId] = TRUE;
|
|
m_ThreadHandle[dwId] = CreateThread (
|
|
NULL, 0,
|
|
(LPTHREAD_START_ROUTINE)WorkerProc,
|
|
(LPVOID)pInfo, 0, &dwThreadId);
|
|
if (m_ThreadHandle[dwId] == NULL) {
|
|
m_Active[dwId] = FALSE;
|
|
delete pInfo;
|
|
} else {
|
|
// establish thread priority
|
|
SetThreadPriority (
|
|
m_ThreadHandle[dwId],
|
|
m_PriorityValue[dwId]);
|
|
}
|
|
}
|
|
|
|
void CStressDlg::SetThreadActivity (CComboBox * cActivityCombo, DWORD dwId)
|
|
{
|
|
switch (cActivityCombo->GetCurSel()) {
|
|
case 0:
|
|
m_ActivityValue[dwId] = SLOW_ACTIVITY;
|
|
break;
|
|
case 1:
|
|
m_ActivityValue[dwId] = MEDIUM_ACTIVITY;
|
|
break;
|
|
case 2:
|
|
m_ActivityValue[dwId] = HIGH_ACTIVITY;
|
|
break;
|
|
case 3:
|
|
m_ActivityValue[dwId] = HOG_ACTIVITY;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CStressDlg::SetThreadPriorityLevel (CComboBox * cPriorityCombo, DWORD dwId)
|
|
{
|
|
LONG lLastError = ERROR_SUCCESS;
|
|
|
|
switch (cPriorityCombo->GetCurSel()) {
|
|
case 0:
|
|
m_PriorityValue[dwId] = (DWORD)THREAD_PRIORITY_IDLE;
|
|
break;
|
|
case 1:
|
|
m_PriorityValue[dwId] = (DWORD)THREAD_PRIORITY_LOWEST;
|
|
break;
|
|
case 2:
|
|
m_PriorityValue[dwId] = (DWORD)THREAD_PRIORITY_BELOW_NORMAL;
|
|
break;
|
|
case 3:
|
|
m_PriorityValue[dwId] = (DWORD)THREAD_PRIORITY_NORMAL;
|
|
break;
|
|
case 4:
|
|
m_PriorityValue[dwId] = (DWORD)THREAD_PRIORITY_ABOVE_NORMAL;
|
|
break;
|
|
case 5:
|
|
m_PriorityValue[dwId] = (DWORD)THREAD_PRIORITY_HIGHEST;
|
|
break;
|
|
case 6:
|
|
m_PriorityValue[dwId] = (DWORD)THREAD_PRIORITY_TIME_CRITICAL;
|
|
break;
|
|
}
|
|
if (m_ThreadHandle[dwId] != NULL) {
|
|
if (!SetThreadPriority (m_ThreadHandle[dwId], m_PriorityValue[dwId])) {
|
|
lLastError = GetLastError ();
|
|
}
|
|
} // else no thread open
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CStressDlg message handlers
|
|
|
|
BOOL CStressDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
// Add "About..." menu item to system menu.
|
|
|
|
// IDM_ABOUTBOX must be in the system command range.
|
|
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
|
|
ASSERT(IDM_ABOUTBOX < 0xF000);
|
|
|
|
CMenu* pSysMenu = GetSystemMenu(FALSE);
|
|
CString strAboutMenu;
|
|
strAboutMenu.LoadString(IDS_ABOUTBOX);
|
|
if (!strAboutMenu.IsEmpty())
|
|
{
|
|
pSysMenu->AppendMenu(MF_SEPARATOR);
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
|
|
}
|
|
|
|
// calibrate loop counter
|
|
m_dwLoopValue = OnePercentCalibration (m_dwLoopValue) * 10;
|
|
|
|
// Set the icon for this dialog. The framework does this automatically
|
|
// when the application's main window is not a dialog
|
|
SetIcon(m_hIcon, TRUE); // Set big icon
|
|
SetIcon(m_hIcon, FALSE); // Set small icon
|
|
|
|
// set the priority of this thread to "highest" so the UI will be
|
|
// responsive
|
|
SetThreadPriority (GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
|
|
|
|
// enable thread 1 & disable all others
|
|
((CComboBox *)GetDlgItem(IDC_PROCESS_PRIORITY))->SetCurSel(1);
|
|
|
|
CheckDlgButton (IDC_1_ACTIVE, 1);
|
|
((CComboBox *)GetDlgItem(IDC_1_PRIORITY))->SetCurSel(3);
|
|
((CComboBox *)GetDlgItem(IDC_1_ACTIVITY))->SetCurSel(0);
|
|
|
|
CheckDlgButton (IDC_2_ACTIVE, 0);
|
|
((CComboBox *)GetDlgItem(IDC_2_PRIORITY))->SetCurSel(3);
|
|
((CComboBox *)GetDlgItem(IDC_2_ACTIVITY))->SetCurSel(0);
|
|
|
|
CheckDlgButton (IDC_3_ACTIVE, 0);
|
|
((CComboBox *)GetDlgItem(IDC_3_PRIORITY))->SetCurSel(3);
|
|
((CComboBox *)GetDlgItem(IDC_3_ACTIVITY))->SetCurSel(0);
|
|
|
|
CheckDlgButton (IDC_4_ACTIVE, 0);
|
|
((CComboBox *)GetDlgItem(IDC_4_PRIORITY))->SetCurSel(3);
|
|
((CComboBox *)GetDlgItem(IDC_4_ACTIVITY))->SetCurSel(0);
|
|
|
|
// set the process priority
|
|
OnSelchangeProcessPriority();
|
|
|
|
// start the first thread
|
|
On1Active();
|
|
|
|
// don't access memory by default
|
|
CheckDlgButton (IDC_USE_MEMORY, 0);
|
|
(GetDlgItem (IDC_SHARED_MEM_SIZE))->EnableWindow (FALSE);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
}
|
|
|
|
void CStressDlg::OnSysCommand(UINT nID, LPARAM lParam)
|
|
{
|
|
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
|
|
{
|
|
CAboutDlg dlgAbout;
|
|
dlgAbout.DoModal();
|
|
}
|
|
else
|
|
{
|
|
CDialog::OnSysCommand(nID, lParam);
|
|
}
|
|
}
|
|
|
|
// If you add a minimize button to your dialog, you will need the code below
|
|
// to draw the icon. For MFC applications using the document/view model,
|
|
// this is automatically done for you by the framework.
|
|
|
|
void CStressDlg::OnPaint()
|
|
{
|
|
if (IsIconic())
|
|
{
|
|
CPaintDC dc(this); // device context for painting
|
|
|
|
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
|
|
|
|
// Center icon in client rectangle
|
|
int cxIcon = GetSystemMetrics(SM_CXICON);
|
|
int cyIcon = GetSystemMetrics(SM_CYICON);
|
|
CRect rect;
|
|
GetClientRect(&rect);
|
|
int x = (rect.Width() - cxIcon + 1) / 2;
|
|
int y = (rect.Height() - cyIcon + 1) / 2;
|
|
|
|
// Draw the icon
|
|
dc.DrawIcon(x, y, m_hIcon);
|
|
}
|
|
else
|
|
{
|
|
CDialog::OnPaint();
|
|
}
|
|
}
|
|
|
|
// The system calls this to obtain the cursor to display while the user drags
|
|
// the minimized window.
|
|
HCURSOR CStressDlg::OnQueryDragIcon()
|
|
{
|
|
return (HCURSOR) m_hIcon;
|
|
}
|
|
|
|
void CStressDlg::On1Active()
|
|
{
|
|
DWORD dwId = 0;
|
|
|
|
if (IsDlgButtonChecked(IDC_1_ACTIVE)) {
|
|
if (m_ThreadHandle[dwId] == NULL) {
|
|
CreateWorkerThread (dwId);
|
|
} else {
|
|
// thread is already running
|
|
}
|
|
} else {
|
|
m_Active[dwId] = FALSE;
|
|
m_ThreadHandle[dwId] = NULL;
|
|
}
|
|
}
|
|
|
|
void CStressDlg::OnSelchange1Activity()
|
|
{
|
|
CComboBox * cActivityCombo;
|
|
DWORD dwId = 0;
|
|
|
|
cActivityCombo = (CComboBox *)GetDlgItem (IDC_1_ACTIVITY);
|
|
SetThreadActivity (cActivityCombo, dwId);
|
|
}
|
|
|
|
void CStressDlg::OnSelchange1Priority()
|
|
{
|
|
CComboBox * cPriorityCombo;
|
|
DWORD dwId = 0;
|
|
|
|
cPriorityCombo = (CComboBox *)GetDlgItem (IDC_1_PRIORITY);
|
|
SetThreadPriorityLevel (cPriorityCombo, dwId);
|
|
}
|
|
|
|
void CStressDlg::On2Active()
|
|
{
|
|
DWORD dwId = 1;
|
|
|
|
if (IsDlgButtonChecked(IDC_2_ACTIVE)) {
|
|
if (m_ThreadHandle[dwId] == NULL) {
|
|
CreateWorkerThread (dwId);
|
|
} else {
|
|
// thread is already running
|
|
}
|
|
} else {
|
|
m_Active[dwId] = FALSE;
|
|
m_ThreadHandle[dwId] = NULL;
|
|
}
|
|
}
|
|
|
|
void CStressDlg::OnSelchange2Activity()
|
|
{
|
|
CComboBox * cActivityCombo;
|
|
DWORD dwId = 1;
|
|
|
|
cActivityCombo = (CComboBox *)GetDlgItem (IDC_2_ACTIVITY);
|
|
SetThreadActivity (cActivityCombo, dwId);
|
|
}
|
|
|
|
void CStressDlg::OnSelchange2Priority()
|
|
{
|
|
CComboBox * cPriorityCombo;
|
|
DWORD dwId = 1;
|
|
|
|
cPriorityCombo = (CComboBox *)GetDlgItem (IDC_2_PRIORITY);
|
|
SetThreadPriorityLevel (cPriorityCombo, dwId);
|
|
}
|
|
|
|
void CStressDlg::On3Active()
|
|
{
|
|
DWORD dwId = 2;
|
|
|
|
if (IsDlgButtonChecked(IDC_3_ACTIVE)) {
|
|
if (m_ThreadHandle[dwId] == NULL) {
|
|
CreateWorkerThread (dwId);
|
|
} else {
|
|
// thread is already running
|
|
}
|
|
} else {
|
|
m_Active[dwId] = FALSE;
|
|
m_ThreadHandle[dwId] = NULL;
|
|
}
|
|
}
|
|
|
|
void CStressDlg::OnSelchange3Activity()
|
|
{
|
|
CComboBox * cActivityCombo;
|
|
DWORD dwId = 2;
|
|
|
|
cActivityCombo = (CComboBox *)GetDlgItem (IDC_3_ACTIVITY);
|
|
SetThreadActivity (cActivityCombo, dwId);
|
|
}
|
|
|
|
void CStressDlg::OnSelchange3Priority()
|
|
{
|
|
CComboBox * cPriorityCombo;
|
|
DWORD dwId = 2;
|
|
|
|
cPriorityCombo = (CComboBox *)GetDlgItem (IDC_3_PRIORITY);
|
|
SetThreadPriorityLevel (cPriorityCombo, dwId);
|
|
}
|
|
|
|
void CStressDlg::On4Active()
|
|
{
|
|
DWORD dwId = 3;
|
|
|
|
if (IsDlgButtonChecked(IDC_4_ACTIVE)) {
|
|
if (m_ThreadHandle[dwId] == NULL) {
|
|
CreateWorkerThread (dwId);
|
|
} else {
|
|
// thread is already running
|
|
}
|
|
} else {
|
|
m_Active[dwId] = FALSE;
|
|
CloseHandle (m_ThreadHandle[dwId]);
|
|
m_ThreadHandle[dwId] = NULL;
|
|
}
|
|
}
|
|
|
|
void CStressDlg::OnSelchange4Activity()
|
|
{
|
|
CComboBox * cActivityCombo;
|
|
DWORD dwId = 3;
|
|
|
|
cActivityCombo = (CComboBox *)GetDlgItem (IDC_4_ACTIVITY);
|
|
SetThreadActivity (cActivityCombo, dwId);
|
|
}
|
|
|
|
void CStressDlg::OnSelchange4Priority()
|
|
{
|
|
CComboBox * cPriorityCombo;
|
|
DWORD dwId = 3;
|
|
|
|
cPriorityCombo = (CComboBox *)GetDlgItem (IDC_4_PRIORITY);
|
|
SetThreadPriorityLevel (cPriorityCombo, dwId);
|
|
}
|
|
|
|
void CStressDlg::OnOK()
|
|
{
|
|
CDialog::OnOK();
|
|
}
|
|
|
|
void CStressDlg::OnSelchangeProcessPriority()
|
|
{
|
|
|
|
CComboBox * cPriorityCombo;
|
|
DWORD dwPriorityClass;
|
|
|
|
cPriorityCombo = (CComboBox *)GetDlgItem (IDC_PROCESS_PRIORITY);
|
|
|
|
switch (cPriorityCombo->GetCurSel()) {
|
|
case 0:
|
|
dwPriorityClass = IDLE_PRIORITY_CLASS;
|
|
break;
|
|
case 1:
|
|
dwPriorityClass = NORMAL_PRIORITY_CLASS;
|
|
break;
|
|
case 2:
|
|
dwPriorityClass = HIGH_PRIORITY_CLASS;
|
|
break;
|
|
}
|
|
SetPriorityClass (GetCurrentProcess(), dwPriorityClass);
|
|
}
|
|
|
|
void CStressDlg::OnKillfocusSharedMemSize()
|
|
{
|
|
return;
|
|
}
|
|
|
|
void CStressDlg::OnChangeSharedMemSize()
|
|
{
|
|
CString csMemSize;
|
|
TCHAR szOldValue[MAX_PATH];
|
|
DWORD dwMemSize;
|
|
|
|
csMemSize.Empty();
|
|
GetDlgItemText (IDC_SHARED_MEM_SIZE, csMemSize);
|
|
dwMemSize = _tcstoul ((LPCTSTR)csMemSize, NULL, 10);
|
|
dwMemSize *= 1024 / sizeof(DWORD);
|
|
|
|
if (dwMemSize != m_dwVASize) {
|
|
// threads must be stopped to change memory size
|
|
if (m_Active[0] || m_Active[1] || m_Active[2] || m_Active[3]) {
|
|
MessageBox (
|
|
TEXT("All threads must be stopped before this value can be changed"));
|
|
_stprintf (szOldValue, TEXT("%d"), ((m_dwVASize * sizeof(DWORD))/1024));
|
|
(GetDlgItem(IDC_SHARED_MEM_SIZE))->SetWindowText(szOldValue);
|
|
return;
|
|
} else {
|
|
if (m_pMemory != NULL) {
|
|
delete (m_pMemory);
|
|
m_pMemory = NULL;
|
|
m_dwVASize = 0;
|
|
}
|
|
m_dwVASize = dwMemSize;
|
|
m_pMemory = new DWORD[m_dwVASize];
|
|
if (m_pMemory == NULL) {
|
|
m_dwVASize = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CStressDlg::OnUseMemory()
|
|
{
|
|
CString csMemSize;
|
|
DWORD dwMemSize;
|
|
BOOL bState;
|
|
|
|
if (m_Active[0] || m_Active[1] || m_Active[2] || m_Active[3]) {
|
|
MessageBox (TEXT("All threads must be stopped before this value can be changed"));
|
|
bState = !IsDlgButtonChecked(IDC_USE_MEMORY); //revert state
|
|
} else {
|
|
if (IsDlgButtonChecked(IDC_USE_MEMORY)) {
|
|
// if no memory is allocated, then allocate it
|
|
if (m_pMemory != NULL) {
|
|
delete (m_pMemory);
|
|
m_pMemory = NULL;
|
|
m_dwVASize = 0;
|
|
}
|
|
//get va size
|
|
csMemSize.Empty();
|
|
GetDlgItemText (IDC_SHARED_MEM_SIZE, csMemSize);
|
|
dwMemSize = _tcstoul ((LPCTSTR)csMemSize, NULL, 10);
|
|
m_dwVASize = dwMemSize * 1024 / sizeof(DWORD);
|
|
m_pMemory = new DWORD[m_dwVASize];
|
|
if (m_pMemory == NULL) {
|
|
m_dwVASize = 0;
|
|
} else {
|
|
m_dwRandomScale = (m_dwVASize / RAND_MAX) + 1;
|
|
}
|
|
bState = TRUE;
|
|
} else {
|
|
// button is unchecked so free memory
|
|
if (m_pMemory != NULL) {
|
|
delete (m_pMemory);
|
|
m_pMemory = NULL;
|
|
m_dwVASize = 0;
|
|
}
|
|
bState = FALSE;
|
|
}
|
|
}
|
|
CheckDlgButton (IDC_USE_MEMORY, bState);
|
|
(GetDlgItem (IDC_SHARED_MEM_SIZE))->EnableWindow (bState);
|
|
}
|
|
|
|
void CStressDlg::OnClose()
|
|
{
|
|
// stop threads first
|
|
m_Active[0] = FALSE;
|
|
m_Active[1] = FALSE;
|
|
m_Active[2] = FALSE;
|
|
m_Active[3] = FALSE;
|
|
|
|
// wait for the threads to finish
|
|
while (m_ThreadHandle[0] || m_ThreadHandle[1] ||
|
|
m_ThreadHandle[2] || m_ThreadHandle[3]) {
|
|
Sleep(100);
|
|
}
|
|
|
|
// free memory block
|
|
if (m_pMemory != NULL) {
|
|
delete (m_pMemory);
|
|
m_pMemory = NULL;
|
|
m_dwVASize = 0;
|
|
}
|
|
|
|
CDialog::OnClose();
|
|
}
|
|
|
|
void CStressDlg::OnDestroy()
|
|
{
|
|
CDialog::OnDestroy();
|
|
}
|