Develop and Download Open Source Software

WinCS

Browse Subversion Repository

/[wincs]/WinCS/WinCSDlg.cpp

Contents of /WinCS/WinCSDlg.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 16 - (show annotations) (download) (as text)
Mon Jun 28 05:40:57 2010 UTC (13 years, 9 months ago) by sho1get
File MIME type: text/x-c++src
File size: 87489 byte(s) 
Update_20100628
1 #include "stdafx.h"
2 #include "WinCS.h"
3 #include "WinCSDlg.h"
4 #include "BMConfirmDlg.h"
5 #include "MasterSettingDlg.h"
6 #include "SlaveSettingDlg.h"
7 #include "EXEConfirmDlg.h"
8 #include "PluginTransferDlg.h"
9 #include "APIReportDlg.h"
10 #include "StructuredException.h"
11
12 #ifdef _DEBUG
13 #define new DEBUG_NEW
14 #endif
15
16 //////////////////////////////////////////////////////////////////////////
17
18 class CAboutDlg : public CDialog
19 {
20 public:
21 CAboutDlg();
22 enum { IDD = IDD_ABOUTBOX };
23
24 protected:
25 DECLARE_MESSAGE_MAP()
26
27 virtual void DoDataExchange(CDataExchange* pDX);
28 };
29
30 BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
31 END_MESSAGE_MAP()
32
33 CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
34 {
35 }
36
37 void CAboutDlg::DoDataExchange(CDataExchange* pDX)
38 {
39 CDialog::DoDataExchange(pDX);
40 }
41
42 //////////////////////////////////////////////////////////////////////////
43
44 BEGIN_MESSAGE_MAP(CWinCSDlg, CDialog)
45 ON_WM_SYSCOMMAND()
46 ON_WM_PAINT()
47 ON_WM_QUERYDRAGICON()
48 //}}AFX_MSG_MAP
49 ON_BN_CLICKED(IDOK, &CWinCSDlg::OnBnClickedOk)
50 ON_MESSAGE(WM_SHOW_FOREGROUND, &CWinCSDlg::OnSetForeground)
51 ON_MESSAGE(WM_SHOWN, &CWinCSDlg::OnShown)
52 ON_MESSAGE(WM_PLUGIN_RELOAD, &CWinCSDlg::OnPluginReload)
53 ON_MESSAGE(WM_PLUGIN_CHANGE, &CWinCSDlg::OnPluginChange)
54 ON_MESSAGE(WM_PLUGIN_TRANSFER, &CWinCSDlg::OnPluginTransfer)
55 ON_MESSAGE(WM_PLUGIN_SENDING, &CWinCSDlg::OnPluginSending)
56 ON_MESSAGE(WM_PLUGIN_LOCK, &CWinCSDlg::OnPluginLock)
57 ON_MESSAGE(WM_SEND_TEXT, &CWinCSDlg::OnSendText)
58 ON_MESSAGE(WM_BMSYSTEM_PROGRESS, &CWinCSDlg::OnBenchmarkProgress)
59 ON_COMMAND(IDM_TOOL_RESTART, &CWinCSDlg::OnToolRestart)
60 ON_COMMAND(IDM_TOOL_STOP, &CWinCSDlg::OnToolStop)
61 ON_COMMAND(IDM_TOOL_EXECUTE, &CWinCSDlg::OnToolExecute)
62 ON_COMMAND(IDM_TOOL_BENCHMARK, &CWinCSDlg::OnToolBenchmark)
63 ON_COMMAND(IDM_TOOL_SETTING, &CWinCSDlg::OnToolSetting)
64 ON_COMMAND(IDM_TOOL_TRANSFER, &CWinCSDlg::OnToolTransfer)
65 ON_COMMAND(IDM_TOOL_FREE_PLUGIN, &CWinCSDlg::OnToolFreePlugin)
66 ON_COMMAND(IDM_TOOL_REFRESH_NODE_LIST, &CWinCSDlg::OnToolRefreshNodeList)
67 ON_COMMAND(IDM_FILE_SAVE_LOG, &CWinCSDlg::OnFileLogoutput)
68 ON_COMMAND(IDM_FILE_CONSOLECLEAR, &CWinCSDlg::OnFileConsoleClear)
69 ON_COMMAND(IDM_FILE_EXIT, &CWinCSDlg::OnFileExit)
70 ON_COMMAND(IDM_HELP_VERSION, &CWinCSDlg::OnHelpVersion)
71 ON_COMMAND_EX(IDT_TB_SETTING, &CWinCSDlg::OnToolBarEvent)
72 ON_COMMAND_EX(IDT_TB_INFORMATION, &CWinCSDlg::OnToolBarEvent)
73 ON_COMMAND_EX(IDT_TB_LOG, &CWinCSDlg::OnToolBarEvent)
74 ON_COMMAND_EX(IDT_TB_EXECUTE, &CWinCSDlg::OnToolBarEvent)
75 ON_COMMAND_EX(IDT_TB_BENCHMARK, &CWinCSDlg::OnToolBarEvent)
76 ON_COMMAND_EX(IDT_TB_STOP, &CWinCSDlg::OnToolBarEvent)
77 ON_COMMAND_EX(IDT_TB_TRANSFER, &CWinCSDlg::OnToolBarEvent)
78 ON_COMMAND_EX(IDT_TB_RESTART, &CWinCSDlg::OnToolBarEvent)
79 ON_WM_CLOSE()
80 END_MESSAGE_MAP()
81
82 CWinCSDlg::CWinCSDlg(CWnd* pParent) : CDialog(CWinCSDlg::IDD, pParent)
83 {
84 m_hIcon = AfxGetApp()->LoadIcon(IDI_WINCS);
85 ZeroMemory(&m_wcsStatus, sizeof(m_wcsStatus));
86 ZeroMemory(&m_MasterSetting, sizeof(m_MasterSetting));
87 ZeroMemory(&m_SlaveSetting, sizeof(m_SlaveSetting));
88 }
89
90 CWinCSDlg::~CWinCSDlg()
91 {
92 FreePlugin(FALSE);
93
94 // GDI+ exit
95 Gdiplus::GdiplusShutdown(m_ulpGdiToken);
96 }
97
98 void CWinCSDlg::DoDataExchange(CDataExchange* pDX)
99 {
100 CDialog::DoDataExchange(pDX);
101 }
102
103 //////////////////////////////////////////////////////////////////////////
104 // WinCS API
105
106 BOOL CWinCSDlg::API_StartPlugin(WORD wPluginID, const CByteArray &arg)
107 {
108 CByteArray data;
109 TCP_DATA tData;
110
111 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
112 {
113 CSingleLock sl(&m_NetLock, TRUE);
114 ZeroMemory(&tData, TCPHDR_SIZE);
115 tData.wMsgType = WCS_MSG_PLUGIN_START;
116 tData.wSrcNodeType = WCS_NODE_MASTER;
117 tData.wDstNodeType = WCS_NODE_SLAVE;
118 tData.wSrcNodeID = m_wcsStatus.wNodeID;
119 tData.wDstNodeID = WCS_DEFAULT_NODE_ID;
120 tData.dwOption = wPluginID;
121 tData.dwDataSize = arg.GetSize();
122
123 data.SetSize(TCPHDR_SIZE + tData.dwDataSize);
124 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
125 CopyMemory(data.GetData() + TCPHDR_SIZE, arg.GetData(), tData.dwDataSize);
126 data.FreeExtra();
127
128 return m_pServerSocket->Broadcast(data);
129 }
130
131 return FALSE;
132 }
133
134 BOOL CWinCSDlg::API_StopPlugin(double dbRuntime)
135 {
136 CByteArray data;
137 TCP_DATA tData;
138 CString cs;
139
140 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
141 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
142
143 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
144 {
145 // Master
146 m_PluginList.fRunning = FALSE;
147 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_WAITING);
148
149 if (m_APIWnd.Graphics.IsAPIWindow())
150 {
151 cs.Format(_T("Runtime: %.4lf sec"), dbRuntime);
152 CMsgBox::Information(MC_CStoSTR(cs), _T("Completed"), m_APIWnd.Graphics.m_hWnd);
153 }
154 }
155 else
156 {
157 // Slave
158 ZeroMemory(&tData, TCPHDR_SIZE);
159 tData.wMsgType = WCS_MSG_PLUGIN_STOP;
160 tData.wSrcNodeType = WCS_NODE_MASTER;
161 tData.wDstNodeType = WCS_NODE_SLAVE;
162 tData.wSrcNodeID = m_wcsStatus.wNodeID;
163 tData.wDstNodeID = WCS_MASTER_NODE_ID;
164
165 data.SetSize(TCPHDR_SIZE);
166 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
167 data.FreeExtra();
168 m_pClientSocket->Send(data);
169
170 cs.Format(_T("Finish plugin : (%s)\r\n>> %s"), GetNowTime(),
171 m_PluginList.list[m_PluginList.nSelect].csModuleName);
172 m_wndSlaveView.AddConsoleText(cs);
173 m_wndSlaveView.EndProgress();
174 m_wndSlaveView.SetPluginRuntime(dbRuntime);
175 }
176
177 return TRUE;
178 }
179
180 BOOL CWinCSDlg::API_StopPlugin(const CalcReportList &list)
181 {
182 CString cs;
183
184 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
185 {
186 m_PluginList.fRunning = FALSE;
187 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
188 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
189
190 if (m_APIWnd.Graphics.IsAPIWindow())
191 {
192 cs.Format(_T("Finish plugin(%s) : (%s)\r\n>> %s"),
193 m_APIWnd.Graphics.IsSystemMode() ? _T("System mode") : _T("Single mode"),
194 GetNowTime(), m_PluginList.list[m_PluginList.nSelect].csModuleName);
195 m_wndMasterView.AddConsoleText(cs);
196 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_WAITING);
197
198 m_APIWnd.Graphics.FinishDrawing();
199 m_APIWnd.Graphics.SetReportList(list);
200 m_APIWnd.Graphics.SetLog(m_MasterSetting.fLogPlugin);
201 m_APIWnd.Graphics.PostMessage(WM_OUTPUT_REPORT);
202 }
203 }
204
205 return TRUE;
206 }
207
208 BOOL CWinCSDlg::API_Broadcast(const CByteArray &data)
209 {
210 CByteArray snd;
211 TCP_DATA tData;
212
213 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
214 {
215 CSingleLock sl(&m_NetLock, TRUE);
216 ZeroMemory(&tData, TCPHDR_SIZE);
217 tData.wMsgType = WCS_MSG_PLUGIN_RAWDATA;
218 tData.wSrcNodeType = WCS_NODE_MASTER;
219 tData.wDstNodeType = WCS_NODE_SLAVE;
220 tData.wSrcNodeID = m_wcsStatus.wNodeID;
221 tData.wDstNodeID = WCS_DEFAULT_NODE_ID;
222 tData.dwDataSize = data.GetSize();
223
224 snd.SetSize(TCPHDR_SIZE + tData.dwDataSize);
225 CopyMemory(snd.GetData(), &tData, TCPHDR_SIZE);
226 CopyMemory(snd.GetData() + TCPHDR_SIZE, data.GetData(), tData.dwDataSize);
227 snd.FreeExtra();
228
229 return m_pServerSocket->Broadcast(snd);
230 }
231
232 return FALSE;
233 }
234
235 BOOL CWinCSDlg::API_SendToMaster(const CByteArray &data)
236 {
237 CByteArray snd;
238 TCP_DATA tData;
239
240 if (m_wcsStatus.wNodeType == WCS_NODE_SLAVE && m_PluginList.fRunning)
241 {
242 CSingleLock sl(&m_NetLock, TRUE);
243 tData.wMsgType = WCS_MSG_PLUGIN_RAWDATA;
244 tData.wSrcNodeType = WCS_NODE_SLAVE;
245 tData.wDstNodeType = WCS_NODE_MASTER;
246 tData.wSrcNodeID = m_wcsStatus.wNodeID;
247 tData.wDstNodeID = WCS_MASTER_NODE_ID;
248 tData.dwDataSize = data.GetSize();
249
250 snd.SetSize(TCPHDR_SIZE + tData.dwDataSize);
251 CopyMemory(snd.GetData(), &tData, TCPHDR_SIZE);
252 CopyMemory(snd.GetData() + TCPHDR_SIZE, data.GetData(), tData.dwDataSize);
253 snd.FreeExtra();
254
255 return m_pClientSocket->Send(snd);
256 }
257
258 return FALSE;
259 }
260
261 BOOL CWinCSDlg::API_CreateGraphWindow(const CString &csName, int cx, int cy, BOOL bFront)
262 {
263 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
264 {
265 return m_APIWnd.Graphics.Create(csName, cx, cy, bFront);
266 }
267
268 return FALSE;
269 }
270
271 BOOL CWinCSDlg::API_SetPixel(int x, int y, COLORREF color)
272 {
273 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
274 {
275 return m_APIWnd.Graphics.SetPixel(x, y, color);
276 }
277
278 return FALSE;
279 }
280
281 BOOL CWinCSDlg::API_SetXLine(int y, int cx, LPCOLORREF lpColor)
282 {
283 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
284 {
285 return m_APIWnd.Graphics.SetXLine(y, cx, lpColor);
286 }
287
288 return FALSE;
289 }
290
291 BOOL CWinCSDlg::API_SetYLine(int x, int cy, LPCOLORREF lpColor)
292 {
293 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
294 {
295 return m_APIWnd.Graphics.SetYLine(x, cy, lpColor);
296 }
297
298 return FALSE;
299 }
300
301 BOOL CWinCSDlg::API_SetTaskSchedule(const NodeInitList &list)
302 {
303 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
304 {
305 return TRUE;
306 }
307
308 return FALSE;
309 }
310
311 void CWinCSDlg::API_SetProgress(DWORD dwIndex, int nPoint)
312 {
313 if (m_wcsStatus.wNodeType == WCS_NODE_SLAVE && m_PluginList.fRunning)
314 {
315 nPoint = (nPoint > 100) ? 100 : nPoint;
316 m_wndSlaveView.SetProgress(dwIndex, nPoint);
317 }
318 }
319
320 void CWinCSDlg::API_InitProgress(DWORD dwProcessors)
321 {
322 if (m_wcsStatus.wNodeType == WCS_NODE_SLAVE && m_PluginList.fRunning)
323 {
324 m_wndSlaveView.InitProgress(dwProcessors);
325 }
326 }
327
328 void CWinCSDlg::API_SetGraphWindowSize(int cx, int cy, int x, int y)
329 {
330 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
331 {
332 m_APIWnd.Graphics.SetWindowSize(cx, cy, x, y);
333 }
334 }
335
336 void CWinCSDlg::API_SetCenterWindow()
337 {
338 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
339 {
340 m_APIWnd.Graphics.SetCenterWindow();
341 }
342 }
343
344 void CWinCSDlg::API_ResetWindow()
345 {
346 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
347 {
348 m_APIWnd.Graphics.ResetWindow();
349 }
350 }
351
352 void CWinCSDlg::API_StartTimer()
353 {
354 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
355 {
356 m_APIWnd.Graphics.StartTimer();
357 }
358 }
359
360 void CWinCSDlg::API_StopTimer()
361 {
362 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER && m_PluginList.fRunning)
363 {
364 m_APIWnd.Graphics.StopTimer();
365 }
366 }
367
368 //////////////////////////////////////////////////////////////////////////
369
370 LRESULT CWinCSDlg::OnPluginReload(WPARAM wParam, LPARAM lParam)
371 {
372 CString cs;
373
374 if (m_wcsStatus.wNodeState != WCS_STATE_EXECUTING)
375 {
376 LoadPlugin();
377 }
378 else
379 {
380 cs.LoadString(IDS_WCS_ERROR_PLUGIN_LOAD);
381 AfxMessageBox(cs);
382 }
383
384 return TRUE;
385 }
386
387 LRESULT CWinCSDlg::OnPluginChange(WPARAM wParam, LPARAM lParam)
388 {
389 CSingleLock sl(&m_PluginList.cs, TRUE);
390
391 UINT nIndex = static_cast<UINT>(wParam);
392 UINT nSize = static_cast<UINT>(m_PluginList.list.GetSize());
393
394 if (nSize > nIndex)
395 {
396 m_PluginList.nSelect = nIndex;
397 m_wndStatusView.SetPluginInfo(m_PluginList.list[nIndex].plgInfo);
398
399 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
400 {
401 m_wndMasterView.SetPluginName(m_PluginList.list[nIndex].csModuleName);
402 }
403 }
404
405 return TRUE;
406 }
407
408 LRESULT CWinCSDlg::OnPluginLock(WPARAM wParam, LPARAM lParam)
409 {
410 BOOL fLock = static_cast<BOOL>(wParam);
411 m_wndStatusView.SetPluginState(fLock);
412 return TRUE;
413 }
414
415 LRESULT CWinCSDlg::OnPluginTransfer(WPARAM wParam, LPARAM lParam)
416 {
417 return OnTransfer(), TRUE;
418 }
419
420 LRESULT CWinCSDlg::OnPluginSending(WPARAM wParam, LPARAM lParam)
421 {
422 CSingleLock sl1(&m_NodeList.cs, TRUE);
423
424 CByteArray data;
425 TCP_DATA tData;
426 TRANSFER tf;
427 IntList list;
428 CString cs1, cs2, csPath, csModule;
429 HANDLE hFile;
430 DWORD dwStrSize, dwFileSize, dwReadSize, dwAddress;
431 WORD wPort, wNodeID;
432 UINT nNSize, nPSize, nIndex;
433 int nPoint, nCount, nSum;
434
435 m_dlgTransfer.GetSendList(list);
436 nPSize = list.GetSize();
437 nNSize = m_NodeList.list.GetSize();
438 nCount = 0;
439 nSum = m_sysStatus.dwSlaves * nPSize;
440
441 for (UINT i = 0; i < nPSize; i++)
442 {
443 nIndex = list[i];
444 csModule = m_PluginList.list[nIndex].csModuleName;
445 dwStrSize = sizeof(TCHAR) * _MAX_FNAME;
446 csPath.Format(_T("./Plugin/%s"), csModule);
447 hFile = CreateFile(csPath, GENERIC_READ, 0, NULL, OPEN_EXISTING,
448 FILE_ATTRIBUTE_NORMAL, NULL);
449
450 if (hFile != INVALID_HANDLE_VALUE)
451 {
452 ZeroMemory(&tf, sizeof(tf.dwFileSize) + dwStrSize);
453 lstrcpy(tf.szFileName, csModule);
454 dwFileSize = GetFileSize(hFile, NULL);
455 tf.dwFileSize = dwFileSize;
456 tf.data.SetSize(dwFileSize);
457
458 if (ReadFile(hFile, tf.data.GetData(), dwFileSize, &dwReadSize, NULL))
459 {
460 m_dlgTransfer.SetPlugin(csModule);
461 tData.data.SetSize(sizeof(tf.dwFileSize) + dwStrSize + dwFileSize);
462 CopyMemory(tData.data.GetData(), &tf.dwFileSize, sizeof(tf.dwFileSize));
463 CopyMemory(tData.data.GetData() + sizeof(tf.dwFileSize), tf.szFileName, dwStrSize);
464 CopyMemory(tData.data.GetData() + sizeof(tf.dwFileSize) + dwStrSize, tf.data.GetData(), dwFileSize);
465
466 ZeroMemory(&tData, TCPHDR_SIZE);
467 tData.wMsgType = WCS_MSG_PLUGIN_TRANSFER;
468 tData.wSrcNodeType = WCS_NODE_MASTER;
469 tData.wDstNodeType = WCS_NODE_SLAVE;
470 tData.wSrcNodeID = m_wcsStatus.wNodeID;
471 tData.dwDataSize = tData.data.GetSize();
472
473 if (m_dlgTransfer.IsSending())
474 {
475 cs1.Format(_T("Send plugin : (%s)\r\n>> %s"), GetNowTime(), tf.szFileName);
476 m_wndMasterView.AddConsoleText(cs1);
477 }
478
479 for (UINT j = 1; j < nNSize; j++)
480 {
481 if (m_dlgTransfer.IsSending())
482 {
483 wPort = m_NodeList.list[j].wPort;
484 wNodeID = m_NodeList.list[j].wNodeID;
485 dwAddress = m_NodeList.list[j].dwAddress;
486 m_dlgTransfer.SetSendToSlave(wNodeID, dwAddress);
487
488 tData.wDstNodeID = wNodeID;
489 data.SetSize(TCPHDR_SIZE + tData.dwDataSize);
490 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
491 CopyMemory(data.GetData() + TCPHDR_SIZE, tData.data.GetData(), tData.dwDataSize);
492 data.FreeExtra();
493
494 if (m_pServerSocket->SendToClient(data, dwAddress, wPort))
495 {
496 nCount++;
497 nPoint = static_cast<int>(nCount * 100 / nSum);
498 m_dlgTransfer.SetProgress(nPoint);
499 }
500 }
501 }
502 }
503
504 CloseHandle(hFile);
505 }
506 else
507 {
508 m_dlgTransfer.PostMessage(WM_PLUGIN_TRANSFER_ERROR, static_cast<WPARAM>(nIndex));
509 }
510 }
511
512 return TRUE;
513 }
514
515 LRESULT CWinCSDlg::OnSendText(WPARAM wParam, LPARAM lParam)
516 {
517 CByteArray data;
518 TCP_DATA tData;
519 CString cs;
520
521 ZeroMemory(&tData, TCPHDR_SIZE);
522
523 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
524 {
525 tData.wMsgType = WCS_MSG_PLAINTEXT;
526 tData.wSrcNodeType = WCS_NODE_MASTER;
527 tData.wDstNodeType = WCS_NODE_SLAVE;
528 tData.wSrcNodeID = m_wcsStatus.wNodeID;
529 tData.wDstNodeID = WCS_DEFAULT_NODE_ID;
530 m_wndMasterView.GetSendMessage(cs);
531 StringToByteArray(cs, tData.data);
532 tData.dwDataSize = tData.data.GetSize();
533
534 data.SetSize(TCPHDR_SIZE + tData.dwDataSize);
535 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
536 CopyMemory(data.GetData() + TCPHDR_SIZE, tData.data.GetData(), tData.dwDataSize);
537 data.FreeExtra();
538 m_pServerSocket->Broadcast(data);
539 }
540 else
541 {
542 tData.wMsgType = WCS_MSG_PLAINTEXT;
543 tData.wSrcNodeType = WCS_NODE_SLAVE;
544 tData.wDstNodeType = WCS_NODE_MASTER;
545 tData.wSrcNodeID = m_wcsStatus.wNodeID;
546 tData.wDstNodeID = WCS_MASTER_NODE_ID;
547 m_wndSlaveView.GetSendMessage(cs);
548 StringToByteArray(cs, tData.data);
549 tData.dwDataSize = tData.data.GetSize();
550
551 data.SetSize(TCPHDR_SIZE + tData.dwDataSize);
552 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
553 CopyMemory(data.GetData() + TCPHDR_SIZE, tData.data.GetData(), tData.dwDataSize);
554 data.FreeExtra();
555 m_pClientSocket->Send(data);
556 }
557
558 return TRUE;
559 }
560
561 LRESULT CWinCSDlg::OnBenchmarkProgress(WPARAM wParam, LPARAM lParam)
562 {
563 CByteArray data;
564 TCP_DATA tData;
565 DWORD dwProgress = static_cast<DWORD>(wParam);
566
567 ZeroMemory(&tData, TCPHDR_SIZE);
568 tData.wMsgType = WCS_MSG_BENCHMARK_PROGRESS;
569 tData.wSrcNodeType = WCS_NODE_SLAVE;
570 tData.wDstNodeType = WCS_NODE_MASTER;
571 tData.wSrcNodeID = m_wcsStatus.wNodeID;
572 tData.wDstNodeID = WCS_MASTER_NODE_ID;
573 tData.dwOption = dwProgress;
574 tData.dwDataSize = 0;
575
576 data.SetSize(TCPHDR_SIZE);
577 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
578 data.FreeExtra();
579 m_pClientSocket->Send(data);
580
581 return TRUE;
582 }
583
584 LRESULT CWinCSDlg::OnShown(WPARAM wParam, LPARAM lParam)
585 {
586 WORD wNodeType = static_cast<WORD>(wParam);
587 m_wndStatusView.SetNodeType(wNodeType);
588 return TRUE;
589 }
590
591 LRESULT CWinCSDlg::OnSetForeground(WPARAM wParam, LPARAM lParam)
592 {
593 if (IsIconic())
594 {
595 ShowWindowAsync(m_hWnd, SW_RESTORE);
596 }
597
598 return SetForegroundWindow();
599 }
600
601 BOOL CWinCSDlg::OnToolBarEvent(UINT nID)
602 {
603 switch (nID)
604 {
605 case IDT_TB_EXECUTE:
606 OnMasterExecute();
607 break;
608
609 case IDT_TB_STOP:
610 OnStop();
611 break;
612
613 case IDT_TB_RESTART:
614 OnRestart();
615 break;
616
617 case IDT_TB_BENCHMARK:
618 OnBenchmark();
619 break;
620
621 case IDT_TB_SETTING:
622 OnSetting();
623 break;
624
625 case IDT_TB_LOG:
626 OnSaveLog();
627 break;
628
629 case IDT_TB_INFORMATION:
630 OnHelp();
631 break;
632
633 case IDT_TB_TRANSFER:
634 OnTransfer();
635 break;
636 }
637
638 return TRUE;
639 }
640
641 void CWinCSDlg::OnToolRestart()
642 {
643 OnRestart();
644 }
645
646 void CWinCSDlg::OnToolStop()
647 {
648 OnStop();
649 }
650
651 void CWinCSDlg::OnToolExecute()
652 {
653 OnMasterExecute();
654 }
655
656 void CWinCSDlg::OnToolBenchmark()
657 {
658 OnBenchmark();
659 }
660
661 void CWinCSDlg::OnToolSetting()
662 {
663 OnSetting();
664 }
665
666 void CWinCSDlg::OnToolTransfer()
667 {
668 OnTransfer();
669 }
670
671 void CWinCSDlg::OnToolFreePlugin()
672 {
673 OnFreePlugin();
674 }
675
676
677 void CWinCSDlg::OnToolRefreshNodeList()
678 {
679 OnRefreshNodeList();
680 }
681
682 void CWinCSDlg::OnFileLogoutput()
683 {
684 OnSaveLog();
685 }
686
687 void CWinCSDlg::OnFileConsoleClear()
688 {
689 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
690 {
691 m_wndMasterView.ClearConsoleText();
692 }
693 else
694 {
695 m_wndSlaveView.ClearConsoleText();
696 }
697 }
698
699 void CWinCSDlg::OnFileExit()
700 {
701 OnExit();
702 }
703
704 void CWinCSDlg::OnHelpVersion()
705 {
706 OnHelp();
707 }
708
709 void CWinCSDlg::OnClose()
710 {
711 int nRet;
712 CString cs;
713
714 cs.LoadString(IDS_WCS_TEXT_SYSTEM_EXIT_CONFIRM);
715 nRet = CMsgBox::Question(MC_CStoSTR(cs), _T("WinCS"), m_hWnd);
716
717 if (nRet == IDYES)
718 {
719 CDialog::OnClose();
720 }
721 }
722
723 //////////////////////////////////////////////////////////////////////////
724
725 void CWinCSDlg::OnExit()
726 {
727 SendMessage(WM_CLOSE);
728 }
729
730 void CWinCSDlg::OnRestart()
731 {
732 PROCESS_INFORMATION pi;
733 STARTUPINFO si;
734 CString cs;
735 BOOL fRet;
736 int nRet = IDYES;
737 TCHAR szCmdLine[] = _T("Restart.exe");
738
739 cs.LoadString(IDS_WCS_TEXT_RESTART_CONFIRM);
740 nRet = CMsgBox::Question(MC_CStoSTR(cs), _T("WinCS"), m_hWnd);
741
742 if (nRet == IDYES)
743 {
744 ZeroMemory(&si, sizeof(si));
745 si.cb = sizeof(si);
746
747 fRet = CreateProcess(NULL,
748 szCmdLine,
749 NULL,
750 NULL,
751 FALSE,
752 NORMAL_PRIORITY_CLASS,
753 NULL,
754 NULL,
755 &si,
756 &pi);
757
758 if (fRet)
759 {
760 CloseHandle(pi.hThread);
761 CloseHandle(pi.hProcess);
762 EndDialog(IDOK);
763 }
764 else
765 {
766 cs.LoadString(IDS_WCS_ERROR_RESTART);
767 AfxMessageBox(cs);
768 }
769
770 EndDialog(IDOK);
771 }
772 }
773
774 void CWinCSDlg::OnSaveLog()
775 {
776 SYSTEMTIME st;
777 CByteArray data;
778 CString csPath, csFile, csText, cs;
779 HANDLE hFile;
780 DWORD dwFileSize, dwWriteSize;
781
782 GetLocalTime(&st);
783 csFile.Format(_T("%04d%02d%02d_%02d%02d%02d.log"),
784 st.wYear, st.wMonth, st.wDay,
785 st.wHour, st.wMinute, st.wSecond);
786 csPath.Format(_T("./Log/Console/%s"), csFile);
787
788 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
789 {
790 m_wndMasterView.GetConsoleText(csText);
791 }
792 else
793 {
794 m_wndSlaveView.GetConsoleText(csText);
795 }
796
797 hFile = CreateFile(csPath, GENERIC_WRITE, 0, NULL, CREATE_NEW,
798 FILE_ATTRIBUTE_NORMAL, NULL);
799
800 if (hFile != INVALID_HANDLE_VALUE)
801 {
802 dwFileSize = csText.GetLength() * sizeof(TCHAR);
803
804 if (WriteFile(hFile, csText, dwFileSize, &dwWriteSize, NULL))
805 {
806 cs.Format(_T("Save complete\r\n%s"), csFile);
807 CMsgBox::Information(MC_CStoSTR(cs), _T("WinCS"), m_hWnd);
808 }
809
810 CloseHandle(hFile);
811 }
812 else
813 {
814 cs.LoadString(IDS_WCS_ERROR_LOGOUTPUT);
815 AfxMessageBox(cs);
816 }
817 }
818
819 void CWinCSDlg::OnSetting()
820 {
821 CString cs;
822
823 if (m_wcsStatus.wNodeState != WCS_STATE_WAITING)
824 {
825 cs.LoadString(IDS_WCS_ERROR_CHANGE_SETTING);
826 AfxMessageBox(cs);
827 return;
828 }
829
830 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
831 {
832 CMasterSettingDlg dlg;
833 int nIndex;
834
835 dlg.SetSetting(m_MasterSetting);
836
837 if (dlg.DoModal() == IDOK)
838 {
839 dlg.GetSetting(m_MasterSetting);
840 m_pServerSocket->SetConnectionMode(m_MasterSetting.fInternet);
841
842 if (m_wcsStatus.dwProcessors != m_MasterSetting.nProcessors)
843 {
844 m_wcsStatus.dwProcessors = m_MasterSetting.nProcessors;
845 nIndex = SearchNodeListIndex(m_wcsStatus.wNodeID);
846
847 if (nIndex != -1)
848 {
849 m_NodeList.cs.Lock();
850 m_NodeList.list[nIndex].dwProcessors = m_wcsStatus.dwProcessors;
851 m_NodeList.cs.Unlock();
852 m_wndMasterView.SetNodeProcessors(m_wcsStatus.wNodeID, m_wcsStatus.dwProcessors);
853 }
854 }
855 }
856 }
857 else
858 {
859 CSlaveSettingDlg dlg;
860 CByteArray data;
861 TCP_DATA tData;
862
863 dlg.SetSetting(m_SlaveSetting);
864
865 if (dlg.DoModal() == IDOK)
866 {
867 dlg.GetSetting(m_SlaveSetting);
868
869 if (m_wcsStatus.dwProcessors != m_SlaveSetting.nProcessors)
870 {
871 m_wcsStatus.dwProcessors = m_SlaveSetting.nProcessors;
872 m_wndSlaveView.SetProcessors(m_wcsStatus.dwProcessors);
873
874 ZeroMemory(&tData, TCPHDR_SIZE);
875 tData.wMsgType = WCS_MSG_CHANGE_PROCESSOR_COUNT;
876 tData.wSrcNodeType = WCS_NODE_SLAVE;
877 tData.wDstNodeType = WCS_NODE_MASTER;
878 tData.wSrcNodeID = m_wcsStatus.wNodeID;
879 tData.wDstNodeID = WCS_MASTER_NODE_ID;
880 tData.dwOption = m_wcsStatus.dwProcessors;
881 tData.dwDataSize = 0;
882
883 data.SetSize(TCPHDR_SIZE);
884 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
885 m_pClientSocket->Send(data);
886 }
887 }
888 }
889 }
890
891 void CWinCSDlg::OnRefreshNodeList()
892 {
893
894 }
895
896 void CWinCSDlg::OnMasterExecute()
897 {
898 CEXEConfirmDlg dlg;
899 NodeDataList list;
900 CByteArray arg;
901 TCP_DATA tData;
902 CALCSIZE size;
903 CString cs, csArg;
904 BOOL fSystem;
905
906 if (m_wcsStatus.wNodeState == WCS_STATE_EXECUTING && IsWindow(m_APIWnd.Graphics.m_hWnd))
907 {
908 m_APIWnd.Graphics.SetForegroundWindow();
909 return;
910 }
911
912 if (m_PluginList.list.GetSize() > 0)
913 {
914 m_NodeList.cs.Lock();
915 list.Copy(m_NodeList.list);
916 m_NodeList.cs.Unlock();
917
918 m_PluginList.list[m_PluginList.nSelect].obj->SetAPI(this);
919 m_PluginList.list[m_PluginList.nSelect].obj->GetCalcSize(size);
920 dlg.SetCalcSize(size);
921 dlg.SetPlugin(m_PluginList.list[m_PluginList.nSelect].csModuleName);
922 dlg.SetSlaves(m_sysStatus.dwSlaves);
923 dlg.SetSystemProcessors(m_sysStatus.dwProcessors);
924 dlg.SetSingleProcessors(m_wcsStatus.dwProcessors);
925
926 if (dlg.DoModal() == IDOK)
927 {
928 fSystem = dlg.IsSystemMode();
929
930 if (fSystem && !PluginTransfer(m_PluginList.nSelect))
931 {
932 cs.LoadString(IDS_WCS_ERROR_PLUGIN_TRANSFER);
933 AfxMessageBox(cs);
934 return;
935 }
936
937 dlg.GetCalcSize(size);
938 dlg.GetArgument(csArg);
939
940 m_TaskManager.InitDataQueue();
941 m_MasterSetting.nRecvCount = 0;
942 m_MasterSetting.nTotalCount = (size.nHeight % size.nRange == 0) ?
943 (size.nHeight / size.nRange) : (size.nHeight / size.nRange) + 1;
944
945 m_APIWnd.Graphics.InitRenderingCount(m_MasterSetting.nTotalCount);
946 m_APIWnd.Graphics.SetCalcSize(size);
947 m_APIWnd.Graphics.SetMode(fSystem);
948 m_APIWnd.Graphics.SetNodeCount(fSystem ? m_sysStatus.dwSlaves : 1);
949 m_APIWnd.Graphics.SetProcessros(fSystem ? m_sysStatus.dwProcessors : m_wcsStatus.dwProcessors);
950
951 StringToByteArray(csArg, arg);
952 m_PluginList.fSystem = fSystem;
953 m_PluginList.list[m_PluginList.nSelect].obj->SetCalcSize(size);
954 m_PluginList.sw.Start();
955
956 CStructuredException::MapSEtoCE();
957
958 try
959 {
960 m_PluginList.fRunning = TRUE;
961
962 if (m_PluginList.list[m_PluginList.nSelect].obj->MasterInitialize(list, fSystem))
963 {
964 m_wcsStatus.wNodeState = WCS_STATE_EXECUTING;
965 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
966 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_EXECUTING);
967
968 if (m_PluginList.list[m_PluginList.nSelect].obj->StartPlugin(arg))
969 {
970 m_PluginList.fRunning = TRUE;
971 cs.Format(_T("Start plugin(%s) : (%s)\r\n>> %s"),
972 fSystem ? _T("System mode") : _T("Single mode"), GetNowTime(),
973 m_PluginList.list[m_PluginList.nSelect].csModuleName);
974 m_wndMasterView.AddConsoleText(cs);
975 }
976 }
977 }
978 catch (CStructuredException se)
979 {
980 m_PluginList.fRunning = FALSE;
981 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
982 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
983 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_WAITING);
984 se.ReportError();
985 }
986 }
987 }
988 else
989 {
990 cs.LoadString(IDS_WCS_ERROR_PLUGIN_EXECUTE);
991 AfxMessageBox(cs);
992 }
993 }
994
995 BOOL CWinCSDlg::OnSlaveExecute(WORD wPluginID, const CByteArray &arg)
996 {
997 SLAVE_PLUGIN init;
998 CString cs;
999 int nIndex = SearchPluginIndex(wPluginID);
1000
1001 if (nIndex != -1)
1002 {
1003 ZeroMemory(&init, sizeof(init));
1004 init.wNodeID = m_wcsStatus.wNodeID;
1005 init.dwProcessors = m_wcsStatus.dwProcessors;
1006 init.dbRuntime = 0.0;
1007
1008 m_PluginList.fRunning = TRUE;
1009 m_wcsStatus.wNodeState = WCS_STATE_EXECUTING;
1010 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1011 m_wndStatusView.SelectPluginList(nIndex);
1012 m_wndStatusView.SetPluginInfo(m_PluginList.list[nIndex].plgInfo);
1013 m_wndSlaveView.SetPlugin(m_PluginList.list[nIndex].csModuleName);
1014 m_wndSlaveView.SetPluginRuntime(0.0);
1015 m_PluginList.nSelect = nIndex;
1016 m_PluginList.list[nIndex].obj->SetAPI(this);
1017 m_PluginList.sw.Start();
1018
1019 if (m_PluginList.list[nIndex].obj->SlaveInitialize(init))
1020 {
1021 if (m_PluginList.list[nIndex].obj->StartPlugin(arg))
1022 {
1023
1024 cs.Format(_T("Start plugin : (%s)\r\n>> %s"), GetNowTime(),
1025 m_PluginList.list[nIndex].csModuleName);
1026 m_wndSlaveView.AddConsoleText(cs);
1027 return TRUE;
1028 }
1029 }
1030
1031 m_PluginList.fRunning = FALSE;
1032 }
1033
1034 return FALSE;
1035 }
1036
1037 void CWinCSDlg::OnBenchmark()
1038 {
1039 CBMConfirmDlg dlg;
1040 CByteArray data;
1041 BM_RANKING br;
1042 DWORDList dwRankList;
1043 TCP_DATA tData;
1044 INT_PTR nRet;
1045 CString cs;
1046 DWORD dwRanking;
1047 UINT nSize;
1048
1049 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
1050 {
1051 // Master event
1052 dlg.SetSlaves(m_sysStatus.dwSlaves);
1053 dlg.SetSystemProcessors(m_sysStatus.dwProcessors);
1054 dlg.SetSingleProcessors(m_wcsStatus.dwProcessors);
1055 nRet = dlg.DoModal();
1056
1057 if (nRet == IDOK)
1058 {
1059 m_wcsStatus.wNodeState = WCS_STATE_BENCHMARKING;
1060 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1061 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_BENCHMARKING);
1062 m_wndMasterView.ResetBenchmark();
1063
1064 if (!dlg.IsSystemMode())
1065 {
1066 // Single Benchmark Test
1067 ZeroMemory(&m_bmSingle.bm, sizeof(m_bmSingle.bm));
1068 cs.Format(_T("Start Benchmark(Single) : (%s)"), GetNowTime());
1069 m_wndMasterView.AddConsoleText(cs);
1070
1071 try
1072 {
1073 m_bmSingle.dlg = CBMSingleDlgPtr(new CBMSingleDlg());
1074 }
1075 catch (std::bad_alloc &)
1076 {
1077 TRACE0("***** ERROR: shared_ptr(bad_alloc) *****\n");
1078 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1079 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1080 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_WAITING);
1081 return;
1082 }
1083
1084 m_bmSingle.dlg->SetNodeType(m_wcsStatus.wNodeType);
1085 m_bmSingle.dlg->SetProcessors(m_wcsStatus.dwProcessors);
1086 nRet = m_bmSingle.dlg->DoModal();
1087
1088 if (nRet == IDOK)
1089 {
1090 m_bmSingle.bm = m_bmSingle.dlg->GetBMData();
1091
1092 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1093 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1094 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_WAITING);
1095
1096 cs.Format(_T("Finish Benchmark(Single) : (%s)\r\n>> Score: %.4lf GFLOPS"),
1097 GetNowTime(), m_bmSingle.bm.dbRltAvg);
1098 m_wndMasterView.AddConsoleText(cs);
1099 m_wndMasterView.SetBenchmarkNodes(1);
1100 m_wndMasterView.SetBenchmarkScore(m_bmSingle.bm.dbRltAvg);
1101 m_wndMasterView.SetBenchmarkRuntime(m_bmSingle.bm.dbRuntime);
1102 m_wndMasterView.SetBenchmarkTestTime(GetNowTime());
1103 }
1104 else
1105 {
1106 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1107 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1108 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_WAITING);
1109 cs.Format(_T("Cancel Benchmark(Single) : (%s)"), GetNowTime());
1110 m_wndMasterView.AddConsoleText(cs);
1111 }
1112 }
1113 else
1114 {
1115 // System Benchmark Test
1116 m_bmSystem.sw.Start();
1117 m_bmSystem.ResultIndexList.RemoveAll();
1118 m_bmSystem.csTestTime = STRING_EMPTY;
1119 m_bmSystem.dbRuntime = 0.0;
1120 m_bmSystem.dbScore = 0.0;
1121 m_bmSystem.dwTestCount = m_sysStatus.dwSlaves; // Remove Master
1122 m_bmSystem.dwTestCompleted = 0;
1123 m_bmSystem.dwProgMax = m_bmSystem.dwTestCount * 10;
1124 m_bmSystem.dwProgPoint = 0;
1125
1126 m_NodeList.cs.Lock();
1127 nSize = m_NodeList.list.GetSize();
1128
1129 for (UINT i = 0; i < nSize; i++)
1130 {
1131 ZeroMemory(&m_NodeList.list[i].bm, sizeof(m_NodeList.list[i].bm));
1132 }
1133
1134 m_NodeList.cs.Unlock();
1135
1136 cs.Format(_T("Start Benchmark(System) : (%s)"), GetNowTime());
1137 m_wndMasterView.AddConsoleText(cs);
1138
1139 ZeroMemory(&tData, TCPHDR_SIZE);
1140 tData.wMsgType = WCS_MSG_BENCHMARK_START;
1141 tData.wSrcNodeType = WCS_NODE_MASTER;
1142 tData.wDstNodeType = WCS_NODE_SLAVE;
1143 tData.wSrcNodeID = m_wcsStatus.wNodeID;
1144 tData.wDstNodeID = WCS_DEFAULT_NODE_ID;
1145 tData.dwDataSize = 0;
1146
1147 data.SetSize(TCPHDR_SIZE);
1148 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
1149 data.FreeExtra();
1150 m_pServerSocket->Broadcast(data);
1151
1152 try
1153 {
1154 m_bmSystem.dlg = CBMSystemDlgPtr(new CBMSystemDlg());
1155 }
1156 catch (std::bad_alloc &)
1157 {
1158 TRACE0("***** ERROR: shared_ptr(bad_alloc) *****\n");
1159 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1160 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1161 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_WAITING);
1162 return;
1163 }
1164
1165 m_NodeList.cs.Lock();
1166 m_bmSystem.dlg->SetNodeList(m_NodeList.list);
1167 m_NodeList.cs.Unlock();
1168 nRet = m_bmSystem.dlg->DoModal();
1169
1170 if (nRet == IDOK)
1171 {
1172 // Benchmark test ranking
1173 nSize = GetNodeCount();
1174 m_bmRankList.RemoveAll();
1175 m_NodeList.cs.Lock();
1176
1177 for (UINT i = 0; i < nSize; i++)
1178 {
1179 if (m_NodeList.list[i].wNodeID != WCS_MASTER_NODE_ID)
1180 {
1181 br.wRanking = 0;
1182 br.wNodeID = m_NodeList.list[i].wNodeID;
1183 br.dbScore = m_NodeList.list[i].bm.dbRltAvg;
1184 m_bmRankList.Add(br);
1185 TRACE2("NodeID: %d - score %lf\n", br.wNodeID, br.dbScore);
1186 }
1187 }
1188
1189 m_NodeList.cs.Unlock();
1190
1191 m_bmRankList.QuickSort(FALSE);
1192 nSize = m_bmRankList.GetSize();
1193
1194 for (UINT i = 0; i < nSize; i++)
1195 {
1196 m_bmRankList[i].wRanking = i + 1;
1197 // MAKELONG(low: NodeID, High: Ranking)
1198 dwRanking = MAKELONG(m_bmRankList[i].wNodeID, m_bmRankList[i].wRanking);
1199 dwRankList.Add(dwRanking);
1200 }
1201
1202 ZeroMemory(&tData, TCPHDR_SIZE);
1203 tData.wMsgType = WCS_MSG_BENCHMARK_RANKING;
1204 tData.wSrcNodeType = WCS_NODE_MASTER;
1205 tData.wDstNodeType = WCS_NODE_SLAVE;
1206 tData.wSrcNodeID = m_wcsStatus.wNodeID;
1207 tData.wDstNodeID = WCS_DEFAULT_NODE_ID;
1208 tData.dwDataSize = dwRankList.GetSize() * sizeof(DWORD);
1209
1210 data.SetSize(TCPHDR_SIZE + tData.dwDataSize);
1211 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
1212 CopyMemory(data.GetData() + TCPHDR_SIZE, &dwRankList[0], tData.dwDataSize);
1213 data.FreeExtra();
1214 m_pServerSocket->Broadcast(data);
1215
1216 cs.Format(_T("Finish Benchmark(System) : (%s)"), GetNowTime());
1217 m_wndMasterView.AddConsoleText(cs);
1218 m_wndMasterView.SetBenchmarkNodes(m_bmSystem.dwTestCount);
1219 m_wndMasterView.SetBenchmarkScore(m_bmSystem.dbScore);
1220 m_wndMasterView.SetBenchmarkRuntime(m_bmSystem.dbRuntime);
1221 m_wndMasterView.SetBenchmarkTestTime(m_bmSystem.csTestTime);
1222 }
1223 else
1224 {
1225 cs.Format(_T("Cancel Benchmark(System) : (%s)"), GetNowTime());
1226 m_wndMasterView.AddConsoleText(cs);
1227
1228 ZeroMemory(&tData, TCPHDR_SIZE);
1229 tData.wMsgType = WCS_MSG_BENCHMARK_CANCEL;
1230 tData.wSrcNodeType = WCS_NODE_MASTER;
1231 tData.wDstNodeType = WCS_NODE_SLAVE;
1232 tData.wSrcNodeID = m_wcsStatus.wNodeID;
1233 tData.wDstNodeID = WCS_DEFAULT_NODE_ID;
1234 tData.dwDataSize = 0;
1235
1236 data.SetSize(TCPHDR_SIZE);
1237 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
1238 data.FreeExtra();
1239 m_pServerSocket->Broadcast(data);
1240 }
1241
1242 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1243 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1244 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_WAITING);
1245 }
1246 }
1247 }
1248 else
1249 {
1250 // Slave event
1251 ZeroMemory(&m_bmSingle.bm, sizeof(m_bmSingle.bm));
1252 cs.Format(_T("Start Benchmark : (%s)"), GetNowTime());
1253 m_wndSlaveView.AddConsoleText(cs);
1254
1255 m_wcsStatus.wNodeState = WCS_STATE_BENCHMARKING;
1256 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1257 m_wndSlaveView.ResetBenchmark();
1258
1259 try
1260 {
1261 m_bmSingle.dlg = CBMSingleDlgPtr(new CBMSingleDlg());
1262 }
1263 catch (std::bad_alloc &)
1264 {
1265 TRACE0("***** ERROR: shared_ptr(bad_alloc) *****\n");
1266 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1267 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1268 return;
1269 }
1270
1271 m_bmSingle.dlg->SetNodeType(m_wcsStatus.wNodeType);
1272 m_bmSingle.dlg->SetProcessors(m_wcsStatus.dwProcessors);
1273 nRet = m_bmSingle.dlg->DoModal();
1274
1275 if (nRet == IDOK)
1276 {
1277 ZeroMemory(&tData, TCPHDR_SIZE);
1278 tData.wMsgType = WCS_MSG_BENCHMARK_RESULT;
1279 tData.wSrcNodeType = WCS_NODE_SLAVE;
1280 tData.wDstNodeType = WCS_NODE_MASTER;
1281 tData.wSrcNodeID = m_wcsStatus.wNodeID;
1282 tData.wDstNodeID = WCS_MASTER_NODE_ID;
1283 tData.dwDataSize = sizeof(m_bmSingle.bm);
1284
1285 m_bmSingle.bm = m_bmSingle.dlg->GetBMData();
1286 data.SetSize(TCPHDR_SIZE + sizeof(m_bmSingle.bm));
1287 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
1288 CopyMemory(data.GetData() + TCPHDR_SIZE, &m_bmSingle.bm, sizeof(m_bmSingle.bm));
1289 data.FreeExtra();
1290 m_pClientSocket->Send(data);
1291
1292 cs.Format(_T("Finish Benchmark(Single) : (%s) \r\n>> Score: %.4lf GFLOPS"),
1293 GetNowTime(), m_bmSingle.bm.dbRltAvg);
1294 m_wndSlaveView.AddConsoleText(cs);
1295 m_wndSlaveView.SetBenchmarkScore(m_bmSingle.bm.dbRltAvg);
1296 m_wndSlaveView.SetBenchmarkRuntime(m_bmSingle.bm.dbRuntime);
1297 m_wndSlaveView.SetBenchmarkTestTime(GetNowTime());
1298 }
1299
1300 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1301 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1302 }
1303 }
1304
1305 void CWinCSDlg::OnStop()
1306 {
1307 CByteArray data;
1308 TCP_DATA tData;
1309 CString cs;
1310
1311 if (m_APIWnd.Graphics.ForceClose())
1312 {
1313 m_PluginList.fRunning = FALSE;
1314 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1315 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1316
1317 cs.Format(_T("Cancel plugin : (%s) \r\n>> %s"), GetNowTime(),
1318 m_PluginList.list[m_PluginList.nSelect].csModuleName);
1319 m_wndMasterView.AddConsoleText(cs);
1320 m_wndMasterView.SetNodeState(m_wcsStatus.wNodeID, WCS_STATE_WAITING);
1321
1322 if (m_APIWnd.Graphics.IsSystemMode())
1323 {
1324 ZeroMemory(&tData, TCPHDR_SIZE);
1325 tData.wMsgType = WCS_MSG_PLUGIN_CANCEL;
1326 tData.wSrcNodeType = WCS_NODE_MASTER;
1327 tData.wDstNodeType = WCS_NODE_SLAVE;
1328 tData.wSrcNodeID = m_wcsStatus.wNodeID;
1329 tData.wDstNodeID = WCS_DEFAULT_NODE_ID;
1330 tData.dwDataSize = 0;
1331
1332 m_PluginList.cs.Lock();
1333 tData.dwOption = m_PluginList.list[m_PluginList.nSelect].plgInfo.wPluginID;
1334 m_PluginList.cs.Unlock();
1335
1336 data.SetSize(TCPHDR_SIZE);
1337 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
1338 data.FreeExtra();
1339 m_pServerSocket->Broadcast(data);
1340 }
1341 }
1342 }
1343
1344 void CWinCSDlg::OnHelp()
1345 {
1346 CAboutDlg dlg;
1347 dlg.DoModal();
1348 }
1349
1350 void CWinCSDlg::OnTransfer()
1351 {
1352 CString cs;
1353
1354 if (m_PluginList.list.GetSize() > 0)
1355 {
1356 if (m_NodeList.list.GetSize() > 1)
1357 {
1358 m_PluginList.cs.Lock();
1359 m_dlgTransfer.SetPluginList(m_PluginList.list);
1360 m_PluginList.cs.Unlock();
1361
1362 m_dlgTransfer.SetCallback(this);
1363 m_dlgTransfer.DoModal();
1364 }
1365 else
1366 {
1367 cs.LoadString(IDS_WCS_ERROR_SLAVE_COUNT);
1368 AfxMessageBox(cs);
1369 }
1370 }
1371 else
1372 {
1373 cs.LoadString(IDS_WCS_ERROR_PLUGIN_LOAD);
1374 AfxMessageBox(cs);
1375 }
1376 }
1377
1378 void CWinCSDlg::OnFreePlugin()
1379 {
1380 CString cs;
1381
1382 if (m_wcsStatus.wNodeState != WCS_STATE_EXECUTING)
1383 {
1384 if (m_wndMasterView.IsPluginLocked())
1385 {
1386 cs.LoadString(IDS_WCS_ERROR_PLUGIN_LOCKED);
1387 AfxMessageBox(cs);
1388 }
1389 else
1390 {
1391 FreePlugin();
1392 }
1393 }
1394 else
1395 {
1396 cs.LoadString(IDS_WCS_ERROR_PLUGIN_LOAD);
1397 AfxMessageBox(cs);
1398 }
1399 }
1400
1401 //////////////////////////////////////////////////////////////////////////
1402
1403 void CWinCSDlg::OnSocketSendMessage(DWORD dwSocketID)
1404 {
1405
1406 }
1407
1408 void CWinCSDlg::OnSocketReceiveMessage(DWORD dwSocketID, NETADDR NetAddr, const CByteArray &data)
1409 {
1410 TCP_DATA tData;
1411 size_t size;
1412
1413 CopyMemory(&tData, data.GetData(), TCPHDR_SIZE);
1414
1415 if (data.GetSize() > TCPHDR_SIZE)
1416 {
1417 size = data.GetSize() - TCPHDR_SIZE;
1418 tData.data.SetSize(size);
1419 CopyMemory(tData.data.GetData(), (data.GetData() + TCPHDR_SIZE), size);
1420 tData.data.FreeExtra();
1421 }
1422
1423 if (dwSocketID == WCS_SOCKID_STREAM_SERVER)
1424 {
1425 // ServerSocket message
1426 ServerReceiveMsgTransaction(tData, NetAddr);
1427 }
1428 else
1429 {
1430 // ClientSocket message
1431 ClientReceiveMsgTransaction(tData, NetAddr);
1432 }
1433 }
1434
1435 void CWinCSDlg::OnSocketReceiveFromMessage(DWORD dwSocketID, NETADDR NetAddr, const CByteArray &data)
1436 {
1437 UDP_DATA uData;
1438
1439 CopyMemory(&uData, data.GetData(), sizeof(uData));
1440
1441 if (dwSocketID == WCS_SOCKID_PEER_SERVER)
1442 {
1443 ServerPeerMsgTransaction(uData, NetAddr);
1444 }
1445 else
1446 {
1447 ClientPeerMsgTransaction(uData, NetAddr);
1448 }
1449 }
1450
1451 void CWinCSDlg::OnSocketAcceptMessage(DWORD dwSocketID, NETADDR NetAddr)
1452 {
1453 ServerAcceptMsgTransaction(NetAddr);
1454 }
1455
1456 void CWinCSDlg::OnSocketConnectMessage(DWORD dwSocketID)
1457 {
1458
1459 }
1460
1461 void CWinCSDlg::OnSocketCloseMessage(DWORD dwSocketID, NETADDR NetAddr)
1462 {
1463 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
1464 {
1465 ServerCloseMsgTransaction(NetAddr);
1466 }
1467 else
1468 {
1469 ClientCloseMsgTransaction();
1470 }
1471 }
1472
1473 //////////////////////////////////////////////////////////////////////////
1474
1475 void CWinCSDlg::ServerPeerMsgTransaction(const UDP_DATA &uData, NETADDR NetAddr)
1476 {
1477 CByteArray data;
1478 UDP_DATA uReply;
1479 SOCKADDR sAddr;
1480 int nLenSA = sizeof(SOCKADDR);
1481
1482 ZeroMemory(&uReply, sizeof(uReply));
1483 data.SetSize(sizeof(UDP_DATA));
1484 data.FreeExtra();
1485
1486 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
1487 {
1488 // Master
1489 switch (uData.wMsgType)
1490 {
1491 case WCS_MSG_MASTER_DISCOVER:
1492 uReply.wMsgType = WCS_MSG_MASTER_OFFER;
1493 uReply.wSrcNodeType = WCS_NODE_MASTER;
1494 uReply.wDstNodeType = WCS_NODE_SLAVE;
1495 uReply.wSrcNodeID = m_wcsStatus.wNodeID;
1496 uReply.wDstNodeID = WCS_DEFAULT_NODE_ID;
1497 CopyMemory(data.GetData(), &uReply, data.GetSize());
1498 MakeSockAddr(&sAddr, NetAddr.dwAddress, NetAddr.wPort);
1499 m_pServerPeerSocket->SendTo(data, &sAddr, nLenSA);
1500 break;
1501 }
1502 }
1503 }
1504
1505 void CWinCSDlg::ClientPeerMsgTransaction(const UDP_DATA &uData, NETADDR NetAddr)
1506 {
1507 }
1508
1509 void CWinCSDlg::ServerReceiveMsgTransaction(const TCP_DATA &tData, NETADDR NetAddr)
1510 {
1511 BM_SYSTEMSCORE bmScore;
1512 CByteArray data;
1513 NODE_DATA nd;
1514 TCP_DATA tReply;
1515 CString cs1, cs2;
1516 BM_DATA bm;
1517 DWORD dwProgPoint, dwProgMax;
1518 UINT nSize;
1519 int nIndex, nPoint, nProcessors;
1520
1521 switch (tData.wMsgType)
1522 {
1523 case WCS_MSG_MASTER_ACCEPT_ACK:
1524 ZeroMemory(&nd, sizeof(nd));
1525 nd.dwAddress = NetAddr.dwAddress;
1526 nd.wPort = NetAddr.wPort;
1527 nd.wNodeID = tData.wSrcNodeID;
1528 nd.wNodeType = tData.wSrcNodeType;
1529 nd.wNodeState = WCS_STATE_WAITING;
1530 nd.dwProcessors = tData.dwOption;
1531 AddNodeList(nd);
1532 m_wndMasterView.AddNodeList(nd);
1533 cs1.Format(_T("The Slave(%d) has been connected : (%s)\r\n>> %s"), tData.wSrcNodeID,
1534 GetNowTime(), DwToIPAddress(NetAddr.dwAddress));
1535 m_wndMasterView.AddConsoleText(cs1);
1536 break;
1537
1538
1539 case WCS_MSG_BENCHMARK_START_ACK:
1540 nIndex = SearchNodeListIndex(tData.wSrcNodeID);
1541
1542 if (nIndex != -1)
1543 {
1544 CSingleLock sl(&m_NodeList.cs, TRUE);
1545 m_NodeList.list[nIndex].wNodeState = WCS_STATE_BENCHMARKING;
1546 m_wndMasterView.SetNodeState(tData.wSrcNodeID, WCS_STATE_BENCHMARKING);
1547 cs1.Format(_T("Start Benchmark - Slave(%d) : (%s)"),
1548 tData.wSrcNodeID, GetNowTime());
1549 m_wndMasterView.AddConsoleText(cs1);
1550 }
1551 break;
1552
1553
1554 case WCS_MSG_BENCHMARK_CANCEL_ACK:
1555 nIndex = SearchNodeListIndex(tData.wSrcNodeID);
1556
1557 if (nIndex != -1)
1558 {
1559 CSingleLock sl(&m_NodeList.cs, TRUE);
1560 m_NodeList.list[nIndex].wNodeState = WCS_STATE_WAITING;
1561 m_wndMasterView.SetNodeState(tData.wSrcNodeID, WCS_STATE_WAITING);
1562 cs1.Format(_T("Cancel Benchmark - Slave(%d) : (%s)"),
1563 tData.wSrcNodeID, GetNowTime());
1564 m_wndMasterView.AddConsoleText(cs1);
1565 }
1566 break;
1567
1568
1569 case WCS_MSG_PLUGIN_START_ACK:
1570 nIndex = SearchNodeListIndex(tData.wSrcNodeID);
1571
1572 if (nIndex != -1)
1573 {
1574 m_NodeList.cs.Lock();
1575 m_NodeList.list[nIndex].wNodeState = WCS_STATE_EXECUTING;
1576 m_NodeList.cs.Unlock();
1577 m_wndMasterView.SetNodeState(tData.wSrcNodeID, WCS_STATE_EXECUTING);
1578 }
1579 break;
1580
1581
1582 case WCS_MSG_PLUGIN_RAWDATA_ACK:
1583 break;
1584
1585
1586 case WCS_MSG_BENCHMARK_RESULT:
1587 nIndex = SearchNodeListIndex(tData.wSrcNodeID);
1588
1589 if (nIndex != -1)
1590 {
1591 SendAckToSlave(tData.wSrcNodeID, WCS_MSG_BENCHMARK_RESULT_ACK);
1592
1593 m_NodeList.cs.Lock();
1594 m_NodeList.list[nIndex].wNodeState = WCS_STATE_WAITING;
1595 m_wndMasterView.SetNodeState(tData.wSrcNodeID, WCS_STATE_WAITING);
1596 CopyMemory(&bm, tData.data.GetData(), sizeof(bm));
1597 m_NodeList.list[nIndex].bm = bm;
1598 m_NodeList.list[nIndex].bm.fSet = TRUE;
1599 m_NodeList.cs.Unlock();
1600
1601 m_bmSystem.dlg->SetTestScore(tData.wSrcNodeID, bm);
1602 cs1.Format(_T("Score of Benchmark - Slave(%d) : (%s)\r\n>> %.4lf GFLOPS"),
1603 tData.wSrcNodeID, GetNowTime(), bm.dbRltAvg);
1604 m_wndMasterView.AddConsoleText(cs1);
1605
1606 m_bmSystem.ResultIndexList.Add(nIndex);
1607 m_bmSystem.dbScore += bm.dbRltAvg;
1608 m_bmSystem.dwTestCompleted += 1;
1609
1610 if (m_bmSystem.dwTestCount == m_bmSystem.dwTestCompleted)
1611 {
1612 ZeroMemory(&bmScore, sizeof(bmScore));
1613 bmScore.dbTotal = m_bmSystem.dbScore;
1614 bmScore.dbAvg = m_bmSystem.dbScore / m_bmSystem.dwTestCount;
1615 bmScore.dbHigh = 0.0;
1616 bmScore.dbLow = static_cast<double>(INT_MAX);
1617 nSize = m_NodeList.list.GetSize();
1618
1619 for (UINT i = 1; i < nSize; i++)
1620 {
1621 if (m_NodeList.list[i].bm.fSet)
1622 {
1623 bmScore.dbHigh = max(bmScore.dbHigh, m_NodeList.list[i].bm.dbRltAvg);
1624 bmScore.dbLow = min(bmScore.dbLow, m_NodeList.list[i].bm.dbRltAvg);
1625 }
1626 }
1627
1628 m_bmSystem.dbRuntime = m_bmSystem.sw.NowBySecond();
1629 m_bmSystem.csTestTime = GetNowTime();
1630 SaveBenchmarkReport(cs1);
1631 m_bmSystem.dlg->SetSystemScore(bmScore, cs1);
1632 }
1633 }
1634 break;
1635
1636
1637 case WCS_MSG_BENCHMARK_PROGRESS:
1638 if (tData.dwOption > 0)
1639 {
1640 m_bmSystem.dwProgPoint += 1;
1641 nPoint = (m_bmSystem.dwProgPoint * 100 / m_bmSystem.dwProgMax);
1642 dwProgPoint = m_bmSystem.dwProgPoint;
1643 dwProgMax = m_bmSystem.dwProgMax;
1644 m_bmSystem.dlg->SetProgressPoint(tData.wSrcNodeID, tData.dwOption * 10);
1645 m_bmSystem.dlg->SetProgress(nPoint);
1646 }
1647 break;
1648
1649
1650 case WCS_MSG_PLAINTEXT:
1651 data.SetSize(tData.dwDataSize);
1652 CopyMemory(data.GetData(), tData.data.GetData(), tData.dwDataSize);
1653 ByteArrayToString(data, cs1);
1654 cs2.Format(_T("Message from the Slave(%d) : (%s)\r\n>> %s"),
1655 tData.wSrcNodeID, GetNowTime(), cs1);
1656 m_wndMasterView.AddConsoleText(cs2);
1657 break;
1658
1659
1660 case WCS_MSG_PLUGIN_RAWDATA:
1661 if (m_wcsStatus.wNodeState == WCS_STATE_EXECUTING)
1662 {
1663 SendAckToSlave(tData.wSrcNodeID, WCS_MSG_PLUGIN_RAWDATA_ACK);
1664 m_APIWnd.Graphics.AddRenderingCount();
1665
1666 if (m_MasterSetting.fRtRendering)
1667 {
1668 m_PluginList.list[m_PluginList.nSelect].obj->ReceiveCallBack(tData.data);
1669 }
1670 else
1671 {
1672 m_TaskManager.DataEnqueue(tData.data);
1673 m_MasterSetting.nRecvCount++;
1674
1675 if (m_MasterSetting.nRecvCount == m_MasterSetting.nTotalCount)
1676 {
1677 while (TRUE)
1678 {
1679 if (m_TaskManager.DataDequeue(data))
1680 {
1681 m_PluginList.list[m_PluginList.nSelect].obj->ReceiveCallBack(data);
1682 }
1683 else
1684 {
1685 break;
1686 }
1687 }
1688 }
1689 }
1690 }
1691 break;
1692
1693
1694 case WCS_MSG_CHANGE_PROCESSOR_COUNT:
1695 nIndex = SearchNodeListIndex(tData.wSrcNodeID);
1696
1697 if (nIndex != -1)
1698 {
1699 m_NodeList.cs.Lock();
1700 nProcessors = static_cast<int>(m_NodeList.list[nIndex].dwProcessors);
1701 m_NodeList.list[nIndex].dwProcessors = tData.dwOption;
1702 nProcessors = static_cast<int>(tData.dwOption) - nProcessors;
1703 m_NodeList.cs.Unlock();
1704 m_sysStatus.dwProcessors = m_sysStatus.dwProcessors + nProcessors;
1705 m_wndMasterView.SetNodeProcessors(tData.wSrcNodeID, tData.dwOption);
1706 m_wndMasterView.SetProcessors(m_sysStatus.dwProcessors);
1707 }
1708 break;
1709
1710
1711 case WCS_MSG_PLUGIN_STOP:
1712 case WCS_MSG_PLUGIN_CANCEL_ACK:
1713 nIndex = SearchNodeListIndex(tData.wSrcNodeID);
1714
1715 if (nIndex != -1)
1716 {
1717 m_NodeList.cs.Lock();
1718 m_NodeList.list[nIndex].wNodeState = WCS_STATE_WAITING;
1719 m_NodeList.cs.Unlock();
1720 m_wndMasterView.SetNodeState(tData.wSrcNodeID, WCS_STATE_WAITING);
1721 }
1722 break;
1723 }
1724 }
1725
1726 void CWinCSDlg::ClientReceiveMsgTransaction(const TCP_DATA &tData, NETADDR NetAddr)
1727 {
1728 CByteArray data;
1729 TRANSFER tf;
1730 CString cs1, cs2, csPath;
1731 HANDLE hFile;
1732 DWORD dwRanking, dwStrSize, dwWriteSize, dwTimeout;
1733 WORD wPluginID;
1734 UINT nSize;
1735 int nRet, nLenSA = sizeof(SOCKADDR);
1736
1737 switch (tData.wMsgType)
1738 {
1739 case WCS_MSG_MASTER_ACCEPT:
1740 m_wcsStatus.wNodeID = tData.wDstNodeID;
1741 m_wcsStatus.wNodeType = WCS_NODE_SLAVE;
1742 SendAckToMaster(WCS_MSG_MASTER_ACCEPT_ACK, m_wcsStatus.dwProcessors);
1743 m_wndStatusView.SetNodeID(m_wcsStatus.wNodeID);
1744 cs1.Format(_T("Connected to the Master : (%s)\r\n>> %s"),
1745 GetNowTime(), DwToIPAddress(NetAddr.dwAddress));
1746 m_wndSlaveView.AddConsoleText(cs1);
1747 break;
1748
1749
1750 case WCS_MSG_BENCHMARK_START:
1751 SendAckToMaster(WCS_MSG_BENCHMARK_START_ACK);
1752 OnBenchmark();
1753 break;
1754
1755
1756 case WCS_MSG_BENCHMARK_CANCEL:
1757 if (m_wcsStatus.wNodeState == WCS_STATE_BENCHMARKING)
1758 {
1759 m_bmSingle.dlg->CancelBenchmarkTest();
1760 cs1.Format(_T("Cancel Benchmark : (%s)"), GetNowTime());
1761 m_wndSlaveView.AddConsoleText(cs1);
1762 SendAckToMaster(WCS_MSG_BENCHMARK_CANCEL_ACK);
1763 }
1764 break;
1765
1766
1767 case WCS_MSG_BENCHMARK_RANKING:
1768 nSize = tData.dwDataSize / sizeof(DWORD);
1769
1770 for (UINT i = 0; i < nSize; i++)
1771 {
1772 CopyMemory(&dwRanking, tData.data.GetData() + (sizeof(DWORD) * i), sizeof(DWORD));
1773
1774 if (LOWORD(dwRanking) == m_wcsStatus.wNodeID)
1775 {
1776 m_wndSlaveView.SetBenchmarkRanking(HIWORD(dwRanking), nSize);
1777 break;
1778 }
1779 }
1780 break;
1781
1782
1783 case WCS_MSG_PLAINTEXT:
1784 data.SetSize(tData.dwDataSize);
1785 CopyMemory(data.GetData(), tData.data.GetData(), tData.dwDataSize);
1786 ByteArrayToString(data, cs1);
1787 cs2.Format(_T("Message from the Master : (%s)\r\n>> %s"), GetNowTime(), cs1);
1788 m_wndSlaveView.AddConsoleText(cs2);
1789 break;
1790
1791
1792 case WCS_MSG_PLUGIN_RAWDATA:
1793 if (m_wcsStatus.wNodeState == WCS_STATE_EXECUTING)
1794 {
1795 SendAckToMaster(WCS_MSG_PLUGIN_RAWDATA_ACK);
1796 m_PluginList.cs.Lock();
1797 m_PluginList.list[m_PluginList.nSelect].obj->ReceiveCallBack(tData.data);
1798 m_PluginList.cs.Unlock();
1799 }
1800 break;
1801
1802
1803 case WCS_MSG_PLUGIN_RAWDATA_ACK:
1804 break;
1805
1806
1807 case WCS_MSG_PLUGIN_START:
1808 if (m_wcsStatus.wNodeState == WCS_STATE_WAITING)
1809 {
1810 wPluginID = static_cast<WORD>(tData.dwOption);
1811
1812 if (OnSlaveExecute(wPluginID, tData.data))
1813 {
1814 SendAckToMaster(WCS_MSG_PLUGIN_START_ACK);
1815 }
1816 }
1817 break;
1818
1819
1820 case WCS_MSG_PLUGIN_CANCEL:
1821 if (m_wcsStatus.wNodeState == WCS_STATE_EXECUTING)
1822 {
1823 wPluginID = static_cast<WORD>(tData.dwOption);
1824 m_PluginList.fRunning = FALSE;
1825
1826 if (m_PluginList.list[m_PluginList.nSelect].plgInfo.wPluginID == wPluginID)
1827 {
1828 dwTimeout = m_PluginList.list[m_PluginList.nSelect].plgInfo.dwTimeout;
1829
1830 if (m_PluginList.list[m_PluginList.nSelect].obj->CancelPlugin(dwTimeout))
1831 {
1832 SendAckToMaster(WCS_MSG_PLUGIN_CANCEL_ACK);
1833 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1834 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1835
1836 cs1.Format(_T("Cancel plugin : (%s) \r\n>> %s"), GetNowTime(),
1837 m_PluginList.list[m_PluginList.nSelect].csModuleName);
1838 m_wndSlaveView.AddConsoleText(cs1);
1839 m_wndSlaveView.CancelPlugin();
1840 }
1841 }
1842 }
1843 break;
1844
1845
1846 case WCS_MSG_PLUGIN_TRANSFER:
1847 if (m_wcsStatus.wNodeState == WCS_STATE_WAITING)
1848 {
1849 CopyMemory(&tf.dwFileSize, tData.data.GetData(), sizeof(tf.dwFileSize));
1850 dwStrSize = sizeof(TCHAR) * _MAX_FNAME;
1851 CopyMemory(tf.szFileName, tData.data.GetData() + sizeof(tf.dwFileSize), dwStrSize);
1852 tf.data.SetSize(tf.dwFileSize);
1853 CopyMemory(tf.data.GetData(), tData.data.GetData() + sizeof(tf.dwFileSize) + dwStrSize, tf.dwFileSize);
1854 csPath.Format(_T("./Plugin/%s"), tf.szFileName);
1855
1856 if (!m_SlaveSetting.fAutoDownload)
1857 {
1858 cs1.LoadStringW(IDS_WCS_TEXT_PLUGIN_DOWNLOAD_CONFIRM);
1859 cs2.Format(_T("%s\r\nPlugin: %s"), cs1, tf.szFileName);
1860 nRet = CMsgBox::Question(MC_CStoSTR(cs2), _T("Plugin download"), m_hWnd);
1861
1862 if (nRet == IDNO)
1863 {
1864 return;
1865 }
1866 }
1867
1868 FreePlugin();
1869
1870 hFile = CreateFile(csPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1871 FILE_ATTRIBUTE_NORMAL, NULL);
1872
1873 if (hFile != INVALID_HANDLE_VALUE)
1874 {
1875 WriteFile(hFile, tf.data.GetData(), tf.dwFileSize, &dwWriteSize, NULL);
1876 CloseHandle(hFile);
1877 cs1.Format(_T("Update plugin : (%s)\r\n>> %s"), GetNowTime(), tf.szFileName);
1878 m_wndSlaveView.AddConsoleText(cs1);
1879 }
1880
1881 LoadPlugin();
1882 }
1883 break;
1884 }
1885 }
1886
1887 void CWinCSDlg::ServerAcceptMsgTransaction(NETADDR NetAddr)
1888 {
1889 CByteArray data;
1890 TCP_DATA tData;
1891
1892 ZeroMemory(&tData, TCPHDR_SIZE);
1893 tData.wMsgType = WCS_MSG_MASTER_ACCEPT;
1894 tData.wSrcNodeType = WCS_NODE_MASTER;
1895 tData.wDstNodeType = WCS_NODE_SLAVE;
1896 tData.wSrcNodeID = m_wcsStatus.wNodeID; // Master(0)
1897 tData.wDstNodeID = ++m_sysStatus.wNodeIndex;
1898 tData.dwDataSize = 0;
1899
1900 data.SetSize(TCPHDR_SIZE);
1901 CopyMemory(data.GetData(), &tData, TCPHDR_SIZE);
1902
1903 #ifdef _DEBUG
1904 if (!m_pServerSocket->SendToClient(data, NetAddr.dwAddress, NetAddr.wPort))
1905 {
1906 TRACE0("***** ERROR: ServerAcceptMsgTransaction *****\n");
1907 }
1908 #else
1909 m_pServerSocket->SendToClient(data, NetAddr.dwAddress, NetAddr.wPort);
1910 #endif
1911 }
1912
1913 void CWinCSDlg::ServerCloseMsgTransaction(NETADDR NetAddr)
1914 {
1915 CString cs;
1916 WORD wNodeID = SearchNodeID(NetAddr.dwAddress, NetAddr.wPort);
1917
1918 if (wNodeID != WCS_DEFAULT_NODE_ID)
1919 {
1920 RemoveNodeList(wNodeID);
1921 cs.Format(_T("The Slave(%d) has been disconnected : (%s)\r\n>> %s"),
1922 wNodeID, GetNowTime(), DwToIPAddress(NetAddr.dwAddress));
1923 m_wndMasterView.RemoveNodeList(wNodeID);
1924 m_wndMasterView.AddConsoleText(cs);
1925 }
1926 }
1927
1928 void CWinCSDlg::ClientCloseMsgTransaction()
1929 {
1930 CString cs;
1931
1932 m_wcsStatus.dwMasterAddress = 0;
1933 m_wcsStatus.wNodeID = WCS_DEFAULT_NODE_ID;
1934 m_wcsStatus.wNodeType = WCS_NODE_UNDEFINED;
1935 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
1936 m_wndStatusView.ResetMasterAddress();
1937 m_wndStatusView.ResetNodeID();
1938 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
1939
1940 // Automatic exit settings
1941 CreateTimerQueueTimer(&m_hSlaveExit, NULL, doAutoExitTimer, this, WCS_SLAVE_AUTOEXIT_TIME, 1000, 0);
1942
1943 cs.LoadString(IDS_WCS_TEXT_MASTER_DISCONNECTED);
1944 CMsgBox::Information(MC_CStoSTR(cs), _T("WinCS Exit"), m_hWnd);
1945
1946 DeleteTimerQueueTimer(NULL, m_hSlaveExit, NULL);
1947
1948 if (m_wcsStatus.wNodeState == WCS_STATE_WAITING)
1949 {
1950 EndDialog(IDOK);
1951 }
1952 }
1953
1954 //////////////////////////////////////////////////////////////////////////
1955
1956 UINT CWinCSDlg::GetNodeCount()
1957 {
1958 return static_cast<UINT>(m_NodeList.list.GetSize());
1959 }
1960
1961 void CWinCSDlg::AddNodeList(NODE_DATA nd)
1962 {
1963 CSingleLock sl(&m_NodeList.cs, TRUE);
1964 m_NodeList.list.Add(nd);
1965 ++m_sysStatus.dwSlaves;
1966 m_sysStatus.dwProcessors += nd.dwProcessors;
1967 m_wndMasterView.SetSlaves(m_sysStatus.dwSlaves);
1968 m_wndMasterView.SetProcessors(m_sysStatus.dwProcessors);
1969
1970 if (m_sysStatus.dwSlaves >= m_MasterSetting.nConnections)
1971 {
1972 m_pServerSocket->SetAccept(FALSE);
1973 }
1974 }
1975
1976 BOOL CWinCSDlg::RemoveNodeList(WORD wNodeID)
1977 {
1978 int nIndex = SearchNodeListIndex(wNodeID);
1979
1980 if (nIndex != -1)
1981 {
1982 CSingleLock sl(&m_NodeList.cs, TRUE);
1983 --m_sysStatus.dwSlaves;
1984 m_sysStatus.dwProcessors -= m_NodeList.list[nIndex].dwProcessors;
1985 m_wndMasterView.SetSlaves(m_sysStatus.dwSlaves);
1986 m_wndMasterView.SetProcessors(m_sysStatus.dwProcessors);
1987 m_NodeList.list.RemoveAt(nIndex);
1988
1989 if (m_sysStatus.dwSlaves < m_MasterSetting.nConnections)
1990 {
1991 m_pServerSocket->SetAccept(TRUE);
1992 }
1993
1994 return TRUE;
1995 }
1996
1997 return FALSE;
1998 }
1999
2000 void CWinCSDlg::RemoveAllNodeList()
2001 {
2002 CSingleLock sl(&m_NodeList.cs, TRUE);
2003 m_NodeList.list.RemoveAll();
2004 m_sysStatus.dwSlaves = 0;
2005 m_sysStatus.dwProcessors = 0;
2006 m_wndMasterView.SetSlaves(m_sysStatus.dwSlaves);
2007 m_wndMasterView.SetProcessors(m_sysStatus.dwProcessors);
2008 m_pServerSocket->SetAccept(TRUE);
2009 }
2010
2011 int CWinCSDlg::SearchNodeListIndex(WORD wNodeID)
2012 {
2013 CSingleLock sl(&m_NodeList.cs, TRUE);
2014 UINT nSize = GetNodeCount();
2015 int nIndex = -1;
2016
2017 for (UINT i = 0; i < nSize; i++)
2018 {
2019 if (m_NodeList.list[i].wNodeID == wNodeID)
2020 {
2021 nIndex = i;
2022 break;
2023 }
2024 }
2025
2026 return nIndex;
2027 }
2028
2029 WORD CWinCSDlg::SearchNodeID(DWORD dwAddress, WORD wPort)
2030 {
2031 CSingleLock sl(&m_NodeList.cs, TRUE);
2032 WORD wNodeID = WCS_DEFAULT_NODE_ID;
2033 UINT nSize = GetNodeCount();
2034
2035 for (UINT i = 0; i < nSize; i++)
2036 {
2037 if ((m_NodeList.list[i].dwAddress == dwAddress) &&
2038 (m_NodeList.list[i].wPort == wPort))
2039 {
2040 wNodeID = m_NodeList.list[i].wNodeID;
2041 break;
2042 }
2043 }
2044
2045 return wNodeID;
2046 }
2047
2048 DWORD CWinCSDlg::GetSAddrBySockAddr(const LPSOCKADDR lpsAddr)
2049 {
2050 SOCKADDR_IN sAddrIn;
2051 CopyMemory(&sAddrIn, lpsAddr, sizeof(sAddrIn));
2052 return sAddrIn.sin_addr.s_addr;
2053 }
2054
2055 WORD CWinCSDlg::GetPortBySockAddr(const LPSOCKADDR lpsAddr)
2056 {
2057 SOCKADDR_IN sAddrIn;
2058 CopyMemory(&sAddrIn, lpsAddr, sizeof(sAddrIn));
2059 return ntohs(sAddrIn.sin_port);
2060 }
2061
2062 //////////////////////////////////////////////////////////////////////////
2063
2064 BOOL CWinCSDlg::OnInitDialog()
2065 {
2066 CDialog::OnInitDialog();
2067
2068 ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
2069 ASSERT(IDM_ABOUTBOX < 0xF000);
2070
2071 CMenu* pSysMenu = GetSystemMenu(FALSE);
2072 if (pSysMenu != NULL)
2073 {
2074 BOOL bNameValid;
2075 CString strAboutMenu;
2076 bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
2077 ASSERT(bNameValid);
2078 if (!strAboutMenu.IsEmpty())
2079 {
2080 pSysMenu->AppendMenu(MF_SEPARATOR);
2081 pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
2082 }
2083 }
2084
2085 SetIcon(m_hIcon, TRUE);
2086 SetIcon(m_hIcon, FALSE);
2087
2088 //////////////////////////////////////////////////////////////////////////
2089
2090 // GDI+ Initialization
2091 Gdiplus::GdiplusStartupInput gdiplusStartupInput;
2092 Gdiplus::GdiplusStartup(&m_ulpGdiToken, &gdiplusStartupInput, NULL);
2093
2094 // Initialization
2095 //CWinCSSetupDlg *pdlg;
2096 CWinCSSetupDlgPtr pdlg;
2097 NODE_DATA nd;
2098 CNetwork net;
2099 IPv4 ipv4List[WCS_MAX_NETSIZE];
2100 TBITEM tbItem[8];
2101 CString cs, csLoad;
2102 CString csTbName[8];
2103 DWORD dwSize = 0;
2104 INT_PTR nRet = -1;
2105 CRect cr;
2106 int nTbSize;
2107
2108 m_sysStatus.wNodeIndex = 0;
2109 m_sysStatus.dwSlaves = 0;
2110 m_sysStatus.dwProcessors = 0;
2111
2112 if (!CreateWcsDirectory())
2113 {
2114 TRACE1("***** ERROR: CreateWcsDirectory(%d)\n", GetLastError());
2115 cs.LoadString(IDS_WCS_ERROR_CREATE_DIRECTORY);
2116 AfxMessageBox(cs);
2117 return EndDialog(IDCANCEL), FALSE;
2118 }
2119
2120 if (!net.GetIPv4List(dwSize, WCS_MAX_NETSIZE, ipv4List))
2121 {
2122 TRACE1("***** ERROR: GetIPv4List(%d)\n", GetLastError());
2123 cs.LoadString(IDS_WCS_ERROR_GET_LOCAL_ADDRESS);
2124 AfxMessageBox(cs);
2125 return EndDialog(IDCANCEL), FALSE;
2126 }
2127
2128 // Set WinCS status
2129 SetWcsStatus();
2130
2131 try
2132 {
2133 pdlg = CWinCSSetupDlgPtr(new CWinCSSetupDlg());
2134 }
2135 catch (std::bad_alloc &)
2136 {
2137 TRACE0("***** ERROR: shared_ptr(bad_alloc) *****\n");
2138 return EndDialog(IDCANCEL), FALSE;
2139 }
2140
2141 CopyMemory(pdlg->m_IPv4List, ipv4List, sizeof(pdlg->m_IPv4List));
2142 pdlg->m_dwListSize = dwSize;
2143
2144 while (TRUE)
2145 {
2146 pdlg->SetWcsStatus(m_wcsStatus);
2147 nRet = pdlg->DoModal();
2148
2149 if (nRet == IDOK)
2150 {
2151 pdlg->GetWcsStatus(m_wcsStatus);
2152
2153 if (!ClientPeerSocketInitialize())
2154 {
2155 return EndDialog(IDCANCEL), FALSE;
2156 }
2157
2158 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
2159 {
2160 // Master
2161 if (StartMaster())
2162 {
2163 break;
2164 }
2165 }
2166 else
2167 {
2168 // Slave
2169 if (StartSlave())
2170 {
2171 break;
2172 }
2173 }
2174 }
2175 else
2176 {
2177 return EndDialog(IDCANCEL), FALSE;
2178 }
2179 }
2180
2181 // Save settings
2182 SaveWcsSettings();
2183
2184 // Status view setting
2185 if (!m_wndStatusView.Create(CStatusView::IDD, this))
2186 {
2187 TRACE1("***** ERROR: StatusView create(%d)\n", GetLastError());
2188 return EndDialog(IDCANCEL), FALSE;
2189 }
2190
2191 m_wndStatusView.GetClientRect(&cr);
2192 cr.OffsetRect(0, 50);
2193 m_wndStatusView.MoveWindow(&cr, FALSE);
2194 m_wndStatusView.ShowWindow(SW_SHOW);
2195
2196 if (m_wcsStatus.wNodeType == WCS_NODE_SLAVE)
2197 {
2198 // Slave view setting
2199 m_SlaveSetting.fAutoDownload = TRUE;
2200 m_SlaveSetting.nProcessors = m_wcsStatus.dwProcessors;
2201
2202 if (!m_wndSlaveView.Create(CSlaveView::IDD, this))
2203 {
2204 TRACE1("***** ERROR: SlaveView create(%d)\n", GetLastError());
2205 return EndDialog(IDCANCEL), FALSE;
2206 }
2207
2208 m_wndSlaveView.GetClientRect(&cr);
2209 cr.OffsetRect(250, 50);
2210 m_wndSlaveView.MoveWindow(&cr, FALSE);
2211 m_wndSlaveView.ShowWindow(SW_SHOW);
2212
2213 // Tool bar
2214 csTbName[0].LoadString(IDT_TB_RESTART);
2215 tbItem[0].nIndex = 0;
2216 tbItem[0].nImageID = IDB_TB_RESTART;
2217 tbItem[0].nInfoID = IDT_TB_RESTART;
2218 tbItem[0].crMask = RGB(255, 255, 255);
2219 tbItem[0].nStyle = TBBS_BUTTON;
2220 tbItem[0].lpText = MC_CStoSTR(csTbName[0]);
2221
2222 csTbName[1].LoadString(IDT_TB_SETTING);
2223 tbItem[1].nIndex = 1;
2224 tbItem[1].nImageID = IDB_TB_SETTING;
2225 tbItem[1].nInfoID = IDT_TB_SETTING;
2226 tbItem[1].crMask = RGB(255, 255, 255);
2227 tbItem[1].nStyle = TBBS_BUTTON;
2228 tbItem[1].lpText = MC_CStoSTR(csTbName[1]);
2229
2230 csTbName[2].LoadString(IDT_TB_LOG);
2231 tbItem[2].nIndex = 2;
2232 tbItem[2].nImageID = IDB_TB_LOG;
2233 tbItem[2].nInfoID = IDT_TB_LOG;
2234 tbItem[2].crMask = RGB(255, 255, 255);
2235 tbItem[2].nStyle = TBBS_BUTTON;
2236 tbItem[2].lpText = MC_CStoSTR(csTbName[2]);
2237
2238 csTbName[3].LoadString(IDT_TB_INFORMATION);
2239 tbItem[3].nIndex = 3;
2240 tbItem[3].nImageID = IDB_TB_INFORMATION;
2241 tbItem[3].nInfoID = IDT_TB_INFORMATION;
2242 tbItem[3].crMask = RGB(255, 255, 255);
2243 tbItem[3].nStyle = TBBS_BUTTON;
2244 tbItem[3].lpText = MC_CStoSTR(csTbName[3]);
2245
2246 // ToolBar size
2247 nTbSize = 4;
2248
2249 // Unable Plugin reload button
2250 m_wndStatusView.SetReloadBtn(FALSE);
2251
2252 // Remove menu
2253 GetMenu()->GetSubMenu(1)->RemoveMenu(IDM_TOOL_EXECUTE, MF_BYCOMMAND);
2254 GetMenu()->GetSubMenu(1)->RemoveMenu(IDM_TOOL_STOP, MF_BYCOMMAND);
2255 GetMenu()->GetSubMenu(1)->RemoveMenu(IDM_TOOL_BENCHMARK, MF_BYCOMMAND);
2256 GetMenu()->GetSubMenu(1)->RemoveMenu(IDM_TOOL_TRANSFER, MF_BYCOMMAND);
2257 GetMenu()->GetSubMenu(1)->RemoveMenu(IDM_TOOL_FREE_PLUGIN, MF_BYCOMMAND);
2258 GetMenu()->GetSubMenu(1)->RemoveMenu(IDM_TOOL_REFRESH_NODE_LIST, MF_BYCOMMAND);
2259 GetMenu()->GetSubMenu(1)->RemoveMenu(3, MF_BYPOSITION);
2260 }
2261 else
2262 {
2263 // Master
2264 m_wcsStatus.wNodeID = 0;
2265 m_MasterSetting.fInternet = TRUE;
2266 m_MasterSetting.fRtRendering = TRUE;
2267 m_MasterSetting.fLogPlugin = TRUE;
2268 m_MasterSetting.nConnections = UINT_MAX;
2269 m_MasterSetting.nProcessors = m_wcsStatus.dwProcessors;
2270 m_MasterSetting.nTotalCount = 0;
2271 m_MasterSetting.nRecvCount = 0;
2272
2273 // Master view setting
2274 if (!m_wndMasterView.Create(CMasterView::IDD, this))
2275 {
2276 TRACE1("***** ERROR: MasterView create(%d)\n", GetLastError());
2277 return EndDialog(IDCANCEL), FALSE;
2278 }
2279
2280 m_wndMasterView.GetClientRect(&cr);
2281 cr.OffsetRect(250, 50);
2282 m_wndMasterView.MoveWindow(&cr, FALSE);
2283 m_wndMasterView.ShowWindow(SW_SHOW);
2284
2285 // Tool bar
2286 csTbName[0].LoadString(IDT_TB_EXECUTE);
2287 tbItem[0].nIndex = 0;
2288 tbItem[0].nImageID = IDB_TB_EXECUTE;
2289 tbItem[0].nInfoID = IDT_TB_EXECUTE;
2290 tbItem[0].crMask = RGB(255, 255, 255);
2291 tbItem[0].nStyle = TBBS_BUTTON;
2292 tbItem[0].lpText = MC_CStoSTR(csTbName[0]);
2293
2294 csTbName[1].LoadString(IDT_TB_STOP);
2295 tbItem[1].nIndex = 1;
2296 tbItem[1].nImageID = IDB_TB_STOP;
2297 tbItem[1].nInfoID = IDT_TB_STOP;
2298 tbItem[1].crMask = RGB(255, 255, 255);
2299 tbItem[1].nStyle = TBBS_BUTTON;
2300 tbItem[1].lpText = MC_CStoSTR(csTbName[1]);
2301
2302 csTbName[2].LoadString(IDT_TB_RESTART);
2303 tbItem[2].nIndex = 2;
2304 tbItem[2].nImageID = IDB_TB_RESTART;
2305 tbItem[2].nInfoID = IDT_TB_RESTART;
2306 tbItem[2].crMask = RGB(255, 255, 255);
2307 tbItem[2].nStyle = TBBS_BUTTON;
2308 tbItem[2].lpText = MC_CStoSTR(csTbName[2]);
2309
2310 csTbName[3].LoadString(IDT_TB_BENCHMARK);
2311 tbItem[3].nIndex = 3;
2312 tbItem[3].nImageID = IDB_TB_BENCHMARK;
2313 tbItem[3].nInfoID = IDT_TB_BENCHMARK;
2314 tbItem[3].crMask = RGB(255, 255, 255);
2315 tbItem[3].nStyle = TBBS_BUTTON;
2316 tbItem[3].lpText = MC_CStoSTR(csTbName[3]);
2317
2318 csTbName[4].LoadString(IDT_TB_SETTING);
2319 tbItem[4].nIndex = 4;
2320 tbItem[4].nImageID = IDB_TB_SETTING;
2321 tbItem[4].nInfoID = IDT_TB_SETTING;
2322 tbItem[4].crMask = RGB(255, 255, 255);
2323 tbItem[4].nStyle = TBBS_BUTTON;
2324 tbItem[4].lpText = MC_CStoSTR(csTbName[4]);
2325
2326 csTbName[5].LoadString(IDT_TB_LOG);
2327 tbItem[5].nIndex = 5;
2328 tbItem[5].nImageID = IDB_TB_LOG;
2329 tbItem[5].nInfoID = IDT_TB_LOG;
2330 tbItem[5].crMask = RGB(255, 255, 255);
2331 tbItem[5].nStyle = TBBS_BUTTON;
2332 tbItem[5].lpText = MC_CStoSTR(csTbName[5]);
2333
2334 csTbName[6].LoadString(IDT_TB_TRANSFER);
2335 tbItem[6].nIndex = 6;
2336 tbItem[6].nImageID = IDB_TB_TRANSFER;
2337 tbItem[6].nInfoID = IDT_TB_TRANSFER;
2338 tbItem[6].crMask = RGB(255, 255, 255);
2339 tbItem[6].nStyle = TBBS_BUTTON;
2340 tbItem[6].lpText = MC_CStoSTR(csTbName[6]);
2341
2342 csTbName[7].LoadString(IDT_TB_INFORMATION);
2343 tbItem[7].nIndex = 7;
2344 tbItem[7].nImageID = IDB_TB_INFORMATION;
2345 tbItem[7].nInfoID = IDT_TB_INFORMATION;
2346 tbItem[7].crMask = RGB(255, 255, 255);
2347 tbItem[7].nStyle = TBBS_BUTTON;
2348 tbItem[7].lpText = MC_CStoSTR(csTbName[7]);
2349
2350 // ToolBar size
2351 nTbSize = 8;
2352
2353 // Add node list
2354 nd.dwAddress = m_wcsStatus.dwLocalAddress;
2355 nd.wPort = m_wcsStatus.wTCPPort;
2356 nd.wNodeID = m_wcsStatus.wNodeID;
2357 nd.wNodeState = m_wcsStatus.wNodeState;
2358 nd.wNodeType = m_wcsStatus.wNodeType;
2359 nd.dwProcessors = m_wcsStatus.dwProcessors;
2360 m_NodeList.list.Add(nd);
2361 m_wndMasterView.AddNodeList(nd);
2362
2363 cs.Format(_T("Start WinCS : (%s)"), GetNowTime());
2364 m_wndMasterView.AddConsoleText(cs);
2365 }
2366
2367 // ToolBar setting
2368 if (!CreateToolBar(tbItem, CSize(22, 22), nTbSize))
2369 {
2370 TRACE1("***** ERROR: ToolBar create(%d)\n", GetLastError());
2371 return EndDialog(IDCANCEL), FALSE;
2372 }
2373
2374 // Status bar
2375 if (!m_wndStatusBar.Create(this))
2376 {
2377 TRACE1("***** ERROR: StatusBar create(%d)\n", GetLastError());
2378 return EndDialog(IDCANCEL), FALSE;
2379 }
2380
2381 RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0);
2382
2383 // Data setting
2384 OutputNodeData();
2385
2386 // Load plugin
2387 if (!LoadPlugin())
2388 {
2389 return EndDialog(IDCANCEL), FALSE;
2390 }
2391
2392 m_fInit = TRUE;
2393
2394 // Set NodeType image
2395 PostMessage(WM_SHOWN, (WPARAM)m_wcsStatus.wNodeType, 0);
2396
2397 return FALSE;
2398 }
2399
2400 void CWinCSDlg::OnSysCommand(UINT nID, LPARAM lParam)
2401 {
2402 if ((nID & 0xFFF0) == IDM_ABOUTBOX)
2403 {
2404 OnHelp();
2405 }
2406 else
2407 {
2408 CDialog::OnSysCommand(nID, lParam);
2409 }
2410 }
2411
2412 void CWinCSDlg::OnPaint()
2413 {
2414 if (IsIconic())
2415 {
2416 CPaintDC dc(this);
2417
2418 SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
2419
2420 int cxIcon = GetSystemMetrics(SM_CXICON);
2421 int cyIcon = GetSystemMetrics(SM_CYICON);
2422 CRect rect;
2423 GetClientRect(&rect);
2424 int x = (rect.Width() - cxIcon + 1) / 2;
2425 int y = (rect.Height() - cyIcon + 1) / 2;
2426
2427 dc.DrawIcon(x, y, m_hIcon);
2428 }
2429 else
2430 {
2431 CDialog::OnPaint();
2432
2433 if (m_fInit)
2434 {
2435 // Repaint
2436 PostMessage(WM_SHOWN, (WPARAM)m_wcsStatus.wNodeType, 0);
2437 }
2438 }
2439 }
2440
2441 HCURSOR CWinCSDlg::OnQueryDragIcon()
2442 {
2443 return static_cast<HCURSOR>(m_hIcon);
2444 }
2445
2446 BOOL CWinCSDlg::StartMaster()
2447 {
2448 SOCKADDR_IN sAddrIn;
2449 LOCALNET net;
2450 SOCKMSG SockMsg;
2451 CString cs, csIP;
2452 int nLenSA = sizeof(SOCKADDR);
2453
2454 if (SearchMaster((LPSOCKADDR)&sAddrIn, &nLenSA))
2455 {
2456 cs.LoadString(IDS_WCS_ERROR_MASTER_DUPLICATED);
2457 csIP.Format(_T("\r\nIP: %s"), DwToIPAddress(sAddrIn.sin_addr.s_addr));
2458 cs += csIP;
2459 AfxMessageBox(cs);
2460 return FALSE;
2461 }
2462
2463 // ClientPeerSocket
2464 if (!m_pClientBcastSocket->AsyncSelect(FD_PEER))
2465 {
2466 m_pClientBcastSocket->CloseSocket();
2467 return FALSE;
2468 }
2469
2470 if (!ServerPeerSocketInitialize())
2471 {
2472 m_pClientBcastSocket->CloseSocket();
2473 return FALSE;
2474 }
2475
2476 // ServerSocket
2477 try
2478 {
2479 m_pServerSocket = CServerSocketPtr(new CServerSocket());
2480 }
2481 catch (std::bad_alloc &)
2482 {
2483 TRACE0("***** ERROR: shared_ptr(bad_alloc) *****\n");
2484 return FALSE;
2485 }
2486
2487 SockMsg.pCallback = this;
2488 SockMsg.dwSocketID = WCS_SOCKID_STREAM_SERVER;
2489
2490 if (!m_pServerSocket->Initialize(SockMsg, m_wcsStatus.wTCPPort, m_wcsStatus.dwLocalAddress))
2491 {
2492 m_pClientBcastSocket->CloseSocket();
2493 m_pServerPeerSocket->CloseSocket();
2494 return FALSE;
2495 }
2496
2497 if (!m_pServerSocket->SetKeepAlive())
2498 {
2499 m_pClientBcastSocket->CloseSocket();
2500 m_pServerPeerSocket->CloseSocket();
2501 return FALSE;
2502 }
2503
2504 m_wcsStatus.dwMasterAddress = m_wcsStatus.dwLocalAddress;
2505 net.dwAddress = m_wcsStatus.dwLocalAddress;
2506 net.dwMask = m_wcsStatus.dwMaskAddress;
2507 net.dwNet = (net.dwAddress & net.dwMask);
2508 m_pServerSocket->SetLocalNet(net);
2509
2510 return TRUE;
2511 }
2512
2513 BOOL CWinCSDlg::StartSlave()
2514 {
2515 SOCKADDR_IN sAddrIn;
2516 LOCALNET net;
2517 SOCKMSG SockMsg;
2518 CString cs, csIP;
2519 int nLenSA = sizeof(SOCKADDR);
2520
2521 if (m_wcsStatus.fDynamic)
2522 {
2523 if (!SearchMaster((LPSOCKADDR)&sAddrIn, &nLenSA))
2524 {
2525 // Master can't discover the network.
2526 cs.LoadString(IDS_WCS_ERROR_MASTER_DISCOVERY);
2527 AfxMessageBox(cs);
2528 return FALSE;
2529 }
2530 else
2531 {
2532 sAddrIn.sin_family = AF_INET;
2533 sAddrIn.sin_port = htons(m_wcsStatus.wTCPPort);
2534 }
2535 }
2536 else
2537 {
2538 sAddrIn.sin_family = AF_INET;
2539 sAddrIn.sin_port = htons(m_wcsStatus.wTCPPort);
2540 sAddrIn.sin_addr.s_addr = m_wcsStatus.dwMasterAddress;
2541 }
2542
2543 // ClientSocket initialize
2544 try
2545 {
2546 m_pClientSocket = CClientSocketPtr(new CClientSocket());
2547 }
2548 catch (std::bad_alloc &)
2549 {
2550 TRACE0("***** ERROR: shared_ptr(bad_alloc) *****\n");
2551 return FALSE;
2552 }
2553
2554 SockMsg.pCallback = this;
2555 SockMsg.dwSocketID = WCS_SOCKID_STREAM_CLIENT;
2556
2557 if (!m_pClientSocket->Initialize(SockMsg))
2558 {
2559 return FALSE;
2560 }
2561
2562 if (!ConnectMaster((LPSOCKADDR)&sAddrIn))
2563 {
2564 m_pClientBcastSocket->CloseSocket();
2565 m_pClientSocket->CloseSocket();
2566
2567 cs.LoadString(IDS_WCS_ERROR_MASTER_CONNECT);
2568 csIP.Format(_T("\r\nIP: %s"), DwToIPAddress(sAddrIn.sin_addr.s_addr));
2569 cs += csIP;
2570 AfxMessageBox(cs);
2571 return FALSE;
2572 }
2573
2574 if (!m_pClientSocket->SetKeepAlive())
2575 {
2576 m_pClientBcastSocket->CloseSocket();
2577 m_pClientSocket->CloseSocket();
2578 return FALSE;
2579 }
2580
2581 if (!m_pClientSocket->AsyncSelect(FD_CLIENT))
2582 {
2583 m_pClientBcastSocket->CloseSocket();
2584 m_pClientSocket->CloseSocket();
2585 return FALSE;
2586 }
2587
2588 // PeerSocket setting
2589 if (!m_pClientBcastSocket->AsyncSelect(FD_PEER))
2590 {
2591 m_pClientBcastSocket->CloseSocket();
2592 m_pClientSocket->CloseSocket();
2593 return FALSE;
2594 }
2595
2596 m_wcsStatus.dwMasterAddress = sAddrIn.sin_addr.s_addr;
2597 net.dwAddress = m_wcsStatus.dwLocalAddress;
2598 net.dwMask = m_wcsStatus.dwMaskAddress;
2599 net.dwNet = (net.dwAddress & net.dwMask);
2600 m_pClientSocket->SetLocalNet(net);
2601
2602 return TRUE;
2603 }
2604
2605 int CWinCSDlg::SearchPluginIndex(WORD wPluginID)
2606 {
2607 CSingleLock sl(&m_PluginList.cs, TRUE);
2608 UINT nSize = m_PluginList.list.GetSize();
2609 int nIndex = -1;
2610
2611 for (UINT i = 0; i < nSize; i++)
2612 {
2613 if (m_PluginList.list[i].plgInfo.wPluginID == wPluginID)
2614 {
2615 nIndex = i;
2616 break;
2617 }
2618 }
2619
2620 m_PluginList.nSelect = nIndex;
2621
2622 return nIndex;
2623 }
2624
2625 void CWinCSDlg::SetWcsStatus()
2626 {
2627 SYSTEM_INFO si;
2628
2629 // Load settings
2630 LoadWcsSettings();
2631
2632 GetSystemInfo(&si);
2633 m_wcsStatus.dwProcessors = si.dwNumberOfProcessors;
2634 m_wcsStatus.wNodeState = WCS_STATE_WAITING;
2635 m_wcsStatus.wNodeID = WCS_DEFAULT_NODE_ID;
2636 }
2637
2638 DWORD CWinCSDlg::MakeBcastAddress(DWORD dwAddress, DWORD dwNetMask)
2639 {
2640 return ((dwAddress & dwNetMask) | (~dwNetMask));
2641 }
2642
2643 BOOL CWinCSDlg::ClientPeerSocketInitialize()
2644 {
2645 // ClientPeerSocket
2646 SOCKMSG SockMsg;
2647
2648 try
2649 {
2650 m_pClientBcastSocket = CBcastSocketPtr(new CBcastSocket());
2651 }
2652 catch (std::bad_alloc &)
2653 {
2654 TRACE0("***** ERROR: shared_ptr(bad_alloc) *****\n");
2655 return FALSE;
2656 }
2657
2658 SockMsg.pCallback = this;
2659 SockMsg.dwSocketID = WCS_SOCKID_PEER_CLIENT;
2660
2661 if (!m_pClientBcastSocket->Initialize(SockMsg, m_wcsStatus.dwLocalAddress, m_wcsStatus.wUDPClientPort))
2662 {
2663 return FALSE;
2664 }
2665
2666 if (!m_pClientBcastSocket->SetSendTimeout(m_wcsStatus.dwTimeout) ||
2667 !m_pClientBcastSocket->SetRecieveTimeout(m_wcsStatus.dwTimeout))
2668 {
2669 m_pClientBcastSocket->CloseSocket();
2670 return FALSE;
2671 }
2672
2673 if (!m_pClientBcastSocket->SetBroadcast(m_wcsStatus.dwBcastAddress, m_wcsStatus.wUDPServerPort))
2674 {
2675 m_pClientBcastSocket->CloseSocket();
2676 return FALSE;
2677 }
2678
2679 return TRUE;
2680 }
2681
2682 BOOL CWinCSDlg::ServerPeerSocketInitialize()
2683 {
2684 // ServerPeerSocket
2685 SOCKMSG SockMsg;
2686
2687 try
2688 {
2689 m_pServerPeerSocket = CPeerSocketPtr(new CPeerSocket());
2690 }
2691 catch (std::bad_alloc &)
2692 {
2693 TRACE0("***** ERROR: shared_ptr(bad_alloc) *****\n");
2694 return FALSE;
2695 }
2696
2697 SockMsg.pCallback = this;
2698 SockMsg.dwSocketID = WCS_SOCKID_PEER_SERVER;
2699
2700 if (!m_pServerPeerSocket->Initialize(SockMsg, m_wcsStatus.dwLocalAddress, m_wcsStatus.wUDPServerPort))
2701 {
2702 return FALSE;
2703 }
2704
2705 if (!m_pServerPeerSocket->SetSendTimeout(m_wcsStatus.dwTimeout) ||
2706 !m_pServerPeerSocket->SetRecieveTimeout(m_wcsStatus.dwTimeout))
2707 {
2708 m_pServerPeerSocket->CloseSocket();
2709 return FALSE;
2710 }
2711
2712 if (!m_pServerPeerSocket->AsyncSelect(FD_PEER))
2713 {
2714 m_pServerPeerSocket->CloseSocket();
2715 return FALSE;
2716 }
2717
2718 return TRUE;
2719 }
2720
2721 BOOL CWinCSDlg::CreateToolBar(LPTBITEM lpTbItem, SIZE size, UINT nBtnNum)
2722 {
2723 int nBtnX, nBtnY;
2724 BOOL fRet;
2725 DWORD dwTBStyle, dwStyle;
2726 CRect cr;
2727 CSize cs;
2728 CBitmap bmp;
2729 CImageList *pImgList;
2730
2731 nBtnX = size.cx;
2732 nBtnY = size.cy;
2733 dwTBStyle = TBSTYLE_FLAT;
2734 dwStyle = WS_CHILD | WS_VISIBLE |
2735 CBRS_TOP |CBRS_TOOLTIPS |
2736 CBRS_FLYBY | CBRS_SIZE_DYNAMIC;
2737
2738 fRet = m_wndToolBar.CreateEx(this, dwTBStyle, dwStyle);
2739 fRet &= m_wndToolBar.LoadToolBar(IDR_MAINFRAME);
2740
2741 if (!fRet)
2742 {
2743 return FALSE;
2744 }
2745
2746 pImgList = m_wndToolBar.GetToolBarCtrl().GetImageList();
2747 pImgList->DeleteImageList();
2748 fRet = pImgList->Create(nBtnX, nBtnY, ILC_COLOR16 | ILC_MASK, 1, 1);
2749
2750 if (!fRet)
2751 {
2752 return FALSE;
2753 }
2754
2755 for (UINT i = 0; i < nBtnNum; i++)
2756 {
2757 if (lpTbItem[i].nStyle == TBBS_BUTTON)
2758 {
2759 fRet = bmp.LoadBitmap(lpTbItem[i].nImageID);
2760
2761 if (fRet)
2762 {
2763 pImgList->Add(&bmp, lpTbItem[i].crMask);
2764 bmp.DeleteObject();
2765 }
2766 }
2767 else
2768 {
2769 // Create dumy bitmap
2770 bmp.CreateBitmap(nBtnX, nBtnY, 1, 1, NULL);
2771 pImgList->Add(&bmp, RGB(0, 0, 0));
2772 bmp.DeleteObject();
2773 }
2774 }
2775 m_wndToolBar.GetToolBarCtrl().SetImageList(pImgList);
2776 m_wndToolBar.GetItemRect(0, &cr);
2777 m_wndToolBar.SetSizes(CSize(cr.Width(), cr.Height() * 2),
2778 CSize(nBtnX, nBtnY));
2779
2780 // ToolBar button setting
2781 m_wndToolBar.SetButtons(NULL, nBtnNum);
2782 for (UINT i = 0; i < nBtnNum; i++)
2783 {
2784 m_wndToolBar.SetButtonInfo(i, lpTbItem[i].nInfoID,
2785 lpTbItem[i].nStyle,
2786 lpTbItem[i].nIndex);
2787
2788 if (lpTbItem[i].nStyle == TBBS_BUTTON)
2789 {
2790 m_wndToolBar.SetButtonText(i, lpTbItem[i].lpText);
2791 }
2792 }
2793
2794 return TRUE;
2795 }
2796
2797 void CWinCSDlg::EnableToolBarBtn(int nCtlID, BOOL fEnable)
2798 {
2799 m_wndToolBar.GetToolBarCtrl().EnableButton(nCtlID, fEnable);
2800 }
2801
2802 BOOL CWinCSDlg::SendAckToMaster(WORD wMsg, DWORD dwOption)
2803 {
2804 CByteArray data;
2805 TCP_DATA tReply;
2806
2807 ZeroMemory(&tReply, TCPHDR_SIZE);
2808 tReply.wMsgType = wMsg;
2809 tReply.wSrcNodeType = WCS_NODE_SLAVE;
2810 tReply.wDstNodeType = WCS_NODE_MASTER;
2811 tReply.wSrcNodeID = m_wcsStatus.wNodeID;
2812 tReply.wDstNodeID = WCS_MASTER_NODE_ID;
2813 tReply.dwOption = dwOption;
2814 tReply.dwDataSize = 0;
2815 data.SetSize(TCPHDR_SIZE);
2816 CopyMemory(data.GetData(), &tReply, TCPHDR_SIZE);
2817 data.FreeExtra();
2818
2819 return m_pClientSocket->Send(data);
2820 }
2821
2822 BOOL CWinCSDlg::SendAckToSlave(WORD wNodeID, WORD wMsg, DWORD dwOption)
2823 {
2824 CByteArray data;
2825 TCP_DATA tReply;
2826 int nIndex = SearchNodeListIndex(wNodeID);
2827
2828 if (nIndex != -1)
2829 {
2830 ZeroMemory(&tReply, TCPHDR_SIZE);
2831 tReply.wMsgType = wMsg;
2832 tReply.wSrcNodeType = WCS_NODE_MASTER;
2833 tReply.wDstNodeType = WCS_NODE_SLAVE;
2834 tReply.wSrcNodeID = m_wcsStatus.wNodeID;
2835 tReply.wDstNodeID = wNodeID;
2836 tReply.dwOption = dwOption;
2837 tReply.dwDataSize = 0;
2838 data.SetSize(TCPHDR_SIZE);
2839 CopyMemory(data.GetData(), &tReply, TCPHDR_SIZE);
2840 data.FreeExtra();
2841
2842 return m_pServerSocket->SendToClient(data, m_NodeList.list[nIndex].dwAddress, m_NodeList.list[nIndex].wPort);
2843 }
2844
2845 return FALSE;
2846 }
2847
2848 BOOL CWinCSDlg::SaveBenchmarkReport(CString &csLogPath)
2849 {
2850 SYSTEMTIME st;
2851 CString cs, csRuntime, csTotal, csReport, csText, csTime, csTxtPath;
2852 HANDLE hFile;
2853 double dbAvg, dbMax, dbMin, dbScore;
2854 DWORD dwFileSize, dwWriteSize;
2855 UINT nSize, nSlaves, nProcessors;
2856 TCHAR szFilePath[_MAX_PATH * 2];
2857
2858 GetLocalTime(&st);
2859 csTxtPath.Format(_T("./Log/Benchmark/System_%04d%02d%02d%02d%02d%02d.html"),
2860 st.wYear, st.wMonth, st.wDay,
2861 st.wHour, st.wMinute, st.wSecond);
2862
2863 _tfullpath(szFilePath, csTxtPath, MC_ARYSIZE(szFilePath) - sizeof(TCHAR));
2864 csLogPath.Format(_T("%s"), szFilePath);
2865 nProcessors = m_sysStatus.dwProcessors;
2866 nSlaves = m_sysStatus.dwSlaves;
2867 dbScore = m_bmSystem.dbScore;
2868
2869 dbAvg = m_bmSystem.dbScore / m_bmSystem.dwTestCount;
2870 dbMax = 0.0;
2871 dbMin = static_cast<double>(INT_MAX);
2872 nSize = m_NodeList.list.GetSize();
2873 csReport += LOG_TEMPLATE_HTML_BENCHMARK_SYSTEM_CAPTION;
2874
2875 for (UINT i = 1; i < nSize; i++)
2876 {
2877 if (m_NodeList.list[i].bm.fSet)
2878 {
2879 cs.Format(LOG_TEMPLATE_HTML_BENCHMARK_SYSTEM_DATA,
2880 m_NodeList.list[i].wNodeID,
2881 DwToIPAddress(m_NodeList.list[i].dwAddress),
2882 m_NodeList.list[i].bm.dbRltAvg);
2883 csReport += cs;
2884 dbMax = max(dbMax, m_NodeList.list[i].bm.dbRltAvg);
2885 dbMin = min(dbMin, m_NodeList.list[i].bm.dbRltAvg);
2886 }
2887 }
2888
2889 m_bmSystem.dlg->GetRuntimeText(csRuntime);
2890 csTime.Format(_T("%04d/%02d/%02d %02d:%02d:%02d"),
2891 st.wYear, st.wMonth, st.wDay,
2892 st.wHour, st.wMinute, st.wSecond);
2893 csTotal.Format(LOG_TEMPLATE_HTML_BENCHMARK_SYSTEM_TOTAL, dbScore);
2894 csText.Format(LOG_TEMPLATE_HTML_BENCHMARK_CONTAINER,
2895 _T("System"), // Mode
2896 csTime, // DateTime
2897 nSlaves, // Nodes
2898 nProcessors, // Processors
2899 csRuntime, // Runtime
2900 csTotal, // Total
2901 dbAvg, // Average
2902 dbMax, // High score
2903 dbMin, // Low score
2904 csReport); // Report data
2905
2906 hFile = CreateFile(csTxtPath, GENERIC_WRITE, 0, NULL, CREATE_NEW,
2907 FILE_ATTRIBUTE_NORMAL, NULL);
2908
2909 if (hFile != INVALID_HANDLE_VALUE)
2910 {
2911 dwFileSize = csText.GetLength() * sizeof(TCHAR);
2912 WriteFile(hFile, csText, dwFileSize, &dwWriteSize, NULL);
2913 CloseHandle(hFile);
2914 return TRUE;
2915 }
2916
2917 return FALSE;
2918 }
2919
2920 void CWinCSDlg::MakeSockAddr(LPSOCKADDR lpsAddr, DWORD dwAddress, WORD wPort, int nFamily)
2921 {
2922 SOCKADDR_IN addr;
2923 addr.sin_port = htons(wPort);
2924 addr.sin_family = nFamily;
2925 addr.sin_addr.s_addr = dwAddress;
2926 CopyMemory(lpsAddr, &addr, sizeof(SOCKADDR));
2927 }
2928
2929 void CWinCSDlg::MakeINetAddr(LPDWORD lpAddress, LPWORD lpPort, const LPSOCKADDR lpsAddr)
2930 {
2931 SOCKADDR_IN addr;
2932 CopyMemory(&addr, lpsAddr, sizeof(addr));
2933 *lpAddress = addr.sin_addr.s_addr;
2934 *lpPort = ntohs(addr.sin_port);
2935 }
2936
2937 BOOL CWinCSDlg::SaveSettings(CString csName, int nValue)
2938 {
2939 CWinApp* pApp = AfxGetApp();
2940 CString csSection = _T("Settings");
2941
2942 ASSERT(pApp);
2943 return pApp->WriteProfileInt(csSection, csName, nValue);
2944 }
2945
2946 UINT CWinCSDlg::LoadSettings(CString csName, int nDefault)
2947 {
2948 CWinApp* pApp = AfxGetApp();
2949 CString csSection = _T("Settings");
2950
2951 ASSERT(pApp);
2952 return pApp->GetProfileInt(csSection, csName, nDefault);
2953 }
2954
2955 void CWinCSDlg::LoadWcsSettings()
2956 {
2957 m_wcsStatus.dwMasterAddress = static_cast<DWORD>(LoadSettings(_T("MasterAddress"), WCS_DEFAULT_MASTER_ADDRESS));
2958 m_wcsStatus.dwBcastAddress = static_cast<DWORD>(LoadSettings(_T("BcastAddress"), WCS_DEFAULT_BCAST_ADDRESS));
2959 m_wcsStatus.dwTimeout = static_cast<DWORD>(LoadSettings(_T("Timeout"), WCS_DEFAULT_TIMEOUT));
2960 m_wcsStatus.wUDPClientPort = static_cast<WORD>(LoadSettings(_T("UDPPortU"), WCS_DEFAULT_UDP_CLIENT_PORT));
2961 m_wcsStatus.wUDPServerPort = static_cast<WORD>(LoadSettings(_T("UDPPortB"), WCS_DEFAULT_UDP_SERVER_PORT));
2962 m_wcsStatus.wTCPPort = static_cast<WORD>(LoadSettings(_T("TCPPort"), WCS_DEFAULT_TCP_PORT));
2963 m_wcsStatus.wRetry = static_cast<WORD>(LoadSettings(_T("Retry"), WCS_DEFAULT_RETRY));
2964 m_wcsStatus.fDynamic = static_cast<BOOL>(LoadSettings(_T("Dynamic"), TRUE));
2965 }
2966
2967 void CWinCSDlg::SaveWcsSettings()
2968 {
2969 SaveSettings(_T("Dynamic"), m_wcsStatus.fDynamic);
2970 SaveSettings(_T("MasterAddress"), m_wcsStatus.dwMasterAddress);
2971 SaveSettings(_T("BcastAddress"), m_wcsStatus.dwBcastAddress);
2972 SaveSettings(_T("UDPPortU"), m_wcsStatus.wUDPClientPort);
2973 SaveSettings(_T("UDPPortB"), m_wcsStatus.wUDPServerPort);
2974 SaveSettings(_T("TCPPort"), m_wcsStatus.wTCPPort);
2975 SaveSettings(_T("Timeout"), m_wcsStatus.dwTimeout);
2976 SaveSettings(_T("Retry"), m_wcsStatus.wRetry);
2977 }
2978
2979 BOOL CWinCSDlg::SearchMaster(LPSOCKADDR lpsAddr, int *lpsAddrLen)
2980 {
2981 CByteArray snd, rcv;
2982 UDP_DATA uData;
2983
2984 uData.wMsgType = WCS_MSG_MASTER_DISCOVER;
2985 uData.wSrcNodeType = WCS_NODE_UNDEFINED;
2986 uData.wDstNodeType = WCS_NODE_MASTER;
2987 uData.wSrcNodeID = m_wcsStatus.wNodeID;
2988 uData.wDstNodeID = WCS_MASTER_NODE_ID;
2989
2990 snd.SetSize(sizeof(uData));
2991 CopyMemory(snd.GetData(), &uData, snd.GetSize());
2992
2993 if (!m_pClientBcastSocket->Broadcast(snd))
2994 {
2995 return FALSE;
2996 }
2997
2998 if (!m_pClientBcastSocket->ReceiveFrom(rcv, lpsAddr, lpsAddrLen))
2999 {
3000 return FALSE;
3001 }
3002
3003 ZeroMemory(&uData, sizeof(uData));
3004 CopyMemory(&uData, rcv.GetData(), UDPHDR_SIZE);
3005
3006 if (!(uData.wMsgType == WCS_MSG_MASTER_OFFER && uData.wSrcNodeType == WCS_NODE_MASTER))
3007 {
3008 return FALSE;
3009 }
3010
3011 return TRUE;
3012 }
3013
3014 BOOL CWinCSDlg::ConnectMaster(const LPSOCKADDR lpMasterAddr)
3015 {
3016 int nLenSA = sizeof(SOCKADDR);
3017
3018 if (!m_pClientSocket->SyncConnect(lpMasterAddr, nLenSA, m_wcsStatus.dwTimeout))
3019 {
3020 return FALSE;
3021 }
3022
3023 return TRUE;
3024 }
3025
3026 void CWinCSDlg::OutputNodeData()
3027 {
3028 m_wndStatusView.SetNodeID(m_wcsStatus.wNodeID);
3029 m_wndStatusView.SetNodeState(m_wcsStatus.wNodeState);
3030 m_wndStatusView.SetMasterAddress(m_wcsStatus.dwMasterAddress);
3031 m_wndStatusView.SetLocalAddress(m_wcsStatus.dwLocalAddress);
3032 m_wndStatusView.SetTCPPort(m_wcsStatus.wTCPPort);
3033
3034 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
3035 {
3036 m_wndStatusView.SetUDPPort(m_wcsStatus.wUDPServerPort);
3037 }
3038 else
3039 {
3040 m_wndStatusView.SetUDPPort(m_wcsStatus.wUDPClientPort);
3041 }
3042 }
3043
3044 BOOL CWinCSDlg::CreateWcsDirectory()
3045 {
3046 CString cs[5];
3047 cs[0] = _T("./Log");
3048 cs[1] = _T("./Log/Console");
3049 cs[2] = _T("./Log/Benchmark");
3050 cs[3] = _T("./Log/Plugin");
3051 cs[4] = _T("./Plugin");
3052
3053 for (UINT i = 0; i < 5; i++)
3054 {
3055 if (!(PathFileExists(cs[i]) && PathIsDirectory(cs[i])))
3056 {
3057 if (!CreateDirectory(cs[i], NULL))
3058 {
3059 return FALSE;
3060 }
3061 }
3062 }
3063
3064 return TRUE;
3065 }
3066
3067 void CWinCSDlg::FreePlugin(BOOL fRefresh)
3068 {
3069 CSingleLock sl(&m_PluginList.cs, TRUE);
3070 UINT nSize = static_cast<UINT>(m_PluginList.list.GetSize());
3071
3072 // Initialization
3073 if (nSize > 0)
3074 {
3075 for (UINT i = 0; i < nSize; i++)
3076 {
3077 if (m_PluginList.list[i].obj != NULL)
3078 {
3079 m_PluginList.list[i].fpRelease(m_PluginList.list[i].obj);
3080 }
3081
3082 FreeLibrary(m_PluginList.list[i].hModule);
3083 }
3084
3085 if (fRefresh)
3086 {
3087 m_PluginList.list.RemoveAll();
3088 m_wndStatusView.DeletePluginList();
3089 m_wndStatusView.PluginInfoClear();
3090
3091 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
3092 {
3093 m_wndMasterView.SetPluginName(STRING_NONE);
3094 }
3095 }
3096 }
3097 }
3098
3099 BOOL CWinCSDlg::LoadPlugin()
3100 {
3101 // DLL plugin loading
3102 CFileFind finder;
3103 CString csProgMsg;
3104 CString csDLL = _T("./Plugin/*.dll");
3105 BOOL flag;
3106 UINT nSize;
3107
3108 FreePlugin();
3109
3110 if (m_wcsStatus.wNodeState != WCS_STATE_WAITING)
3111 {
3112 return FALSE;
3113 }
3114
3115 CSingleLock sl(&m_PluginList.cs, TRUE);
3116
3117 flag = finder.FindFile(csDLL);
3118
3119 while (flag)
3120 {
3121 flag = finder.FindNextFile();
3122 if (!finder.IsDots())
3123 {
3124 LoadExcutionPlugin(finder.GetFilePath());
3125 }
3126 }
3127
3128 nSize = static_cast<UINT>(m_PluginList.list.GetSize());
3129
3130 if (nSize > 0)
3131 {
3132 for (UINT i = 0; i < nSize; i++)
3133 {
3134 m_wndStatusView.AddPluginList(m_PluginList.list[i].csModuleName);
3135 }
3136
3137 m_PluginList.nSelect = 0;
3138 m_PluginList.fRunning = FALSE;
3139 m_wndStatusView.SelectPluginList(0);
3140 m_wndStatusView.SetPluginInfo(m_PluginList.list[0].plgInfo);
3141
3142 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
3143 {
3144 m_wndMasterView.SetPluginName(m_PluginList.list[0].csModuleName);
3145 }
3146 }
3147 else
3148 {
3149 if (m_wcsStatus.wNodeType == WCS_NODE_MASTER)
3150 {
3151 m_wndMasterView.SetPluginName(STRING_NONE);
3152 }
3153 }
3154
3155 return TRUE;
3156 }
3157
3158 BOOL CWinCSDlg::LoadExcutionPlugin(const CString &csFilePath)
3159 {
3160 CString csFileName;
3161 PLUGIN pin;
3162 UINT nSize;
3163 BOOL fBuild;
3164
3165 ZeroMemory(&pin.plgInfo, sizeof(pin.plgInfo));
3166 pin.obj = NULL;
3167 csFileName = PathFindFileName(csFilePath);
3168 pin.hModule = LoadLibrary(csFilePath);
3169
3170 if (pin.hModule == NULL)
3171 {
3172 return FALSE;
3173 }
3174
3175 pin.fpCreate = (CREATE_PLUGIN)GetProcAddress(pin.hModule, "CreatePlugin");
3176
3177 if (pin.fpCreate == NULL)
3178 {
3179 TRACE0("***** ERROR: Couldn't get function(CreatePlugin) *****\n");
3180 FreeLibrary(pin.hModule);
3181 return FALSE;
3182 }
3183
3184 pin.fpRelease = (RELEASE_PLUGIN)GetProcAddress(pin.hModule, "ReleasePlugin");
3185
3186 if (pin.fpRelease == NULL)
3187 {
3188 TRACE0("***** ERROR: Couldn't get function(ReleasePlugin) *****\n");
3189 FreeLibrary(pin.hModule);
3190 return FALSE;
3191 }
3192
3193 pin.obj = pin.fpCreate();
3194
3195 if (pin.obj == NULL)
3196 {
3197 TRACE0("***** ERROR: Create Plugin instance(bad_alloc) *****\n");
3198 FreeLibrary(pin.hModule);
3199 return FALSE;
3200