Develop and Download Open Source Software

WinCS

Browse Subversion Repository

/[wincs]/WinCS/WinCSDlg.cpp

Annotation of /WinCS/WinCSDlg.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 16 - (hide 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 sho1get 11 #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 sho1get 16 m_dlgTransfer.SetCallback(this);
1363 sho1get 11 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 sho1get 16 SOCKADDR sAddr;
1480 sho1get 11 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 sho1get 16 MakeSockAddr(&sAddr, NetAddr.dwAddress, NetAddr.wPort);
1499     m_pServerPeerSocket->SendTo(data, &sAddr, nLenSA);
1500 sho1get 11 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 sho1get 16 DWORD CWinCSDlg::GetSAddrBySockAddr(const LPSOCKADDR lpsAddr)
2049 sho1get 11 {
2050 sho1get 16 SOCKADDR_IN sAddrIn;
2051     CopyMemory(&sAddrIn, lpsAddr, sizeof(sAddrIn));
2052     return sAddrIn.sin_addr.s_addr;
2053 sho1get 11 }
2054    
2055 sho1get 16 WORD CWinCSDlg::GetPortBySockAddr(const LPSOCKADDR lpsAddr)
2056 sho1get 11 {
2057 sho1get 16 SOCKADDR_IN sAddrIn;
2058     CopyMemory(&sAddrIn, lpsAddr, sizeof(sAddrIn));
2059     return ntohs(sAddrIn.sin_port);
2060 sho1get 11 }
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 sho1get 16 SOCKADDR_IN sAddrIn;
2449 sho1get 11 LOCALNET net;
2450     SOCKMSG SockMsg;
2451     CString cs, csIP;
2452     int nLenSA = sizeof(SOCKADDR);
2453    
2454 sho1get 16 if (SearchMaster((LPSOCKADDR)&sAddrIn, &nLenSA))
2455 sho1get 11 {
2456     cs.LoadString(IDS_WCS_ERROR_MASTER_DUPLICATED);
2457 sho1get 16 csIP.Format(_T("\r\nIP: %s"), DwToIPAddress(sAddrIn.sin_addr.s_addr));
2458 sho1get 11 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 sho1get 16 SockMsg.pCallback = this;
2488 sho1get 11 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 sho1get 16 SOCKADDR_IN sAddrIn;
2516 sho1get 11 LOCALNET net;
2517     SOCKMSG SockMsg;
2518     CString cs, csIP;
2519     int nLenSA = sizeof(SOCKADDR);
2520