|
Neither the code, nor the explanation about the goal of your program is enough. Looking at the code I'm almost sure your threading isn't correct.
|
|
|
|
|
AndrewG1231 wrote:
My goal is to make the data acquired and then displayed continuously.
Remember that you cannot update the UI from the secondary thread. Have the worker thread "post" a message to the primary thread (the one that owns the UI).
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"Show me a community that obeys the Ten Commandments and I'll show you a less crowded prison system." - Anonymous
|
|
|
|
|
Ok, so the thread is merely obtaining the information and being passed elsewhere for updating the UI? This would explain why the for loop attempt failed. So, I must look for the area of the code where the data is drawn is your suggestion?
|
|
|
|
|
The less hassle free solution is sending a message from the worker thread to the ui thread by using SendMessage() or PostMessage() with one of your windows.
|
|
|
|
|
Thank you for the suggestion, but I am unfamiliar with SendMessage() and PostMessage(). Would you be able to give me an example of how to do this or direct me to a good tutorial/article?
|
|
|
|
|
Its easy. Inside your program every window belongs to a thread - the thread that created the window (note that in a normal program every window is created by a single thread). That thread has a message queue. Every time you do something to the window - click on it with the mouse, request redrawing part of its client area - a message for that window is put in the message queue of the thread that handles that window. The gui thread should remove messages and process them in a loop (this is called the main message loop: GetMessage/DispatchMessage funcionts). In your case MFC does this for you, in pure win32 you do that for yourself. The window messages (WM_LBUTTONDOWN, WM_CLOSE, WM_PAINT, etc...) are also messages that come from that message queue, and when the gui thread encounters such a window message it dispatches that to the windowproc of the right window. OK, how is this related to worker threads? Actually message queues are one of the best things to use as inter-thread communication and fortunately this thread-message queue is thread safe, you can put a message to it from any other thread. For example you can put a window message into the message queue of the gui thread by calling PostMessage() or SendMessage() form your worker thread. Both of these functions put a message to the message queue of the gui thread but PostMessage() returns immediately while SendMessage() blocks the execution of the caller thread and returns only after the gui thread has processed the message. OK, but where to send the message, and what message??? You should define your own window messages by starting from the WM_APP constant. You define for example WM_APP+0 and WM_APP+1 and so on as your thread messages. With PostMessage() and SendMessage() you can send these custom messages to your main window and you can also specify 2 integer parameters: wParam and lParam (lParam is somtimes used as a pointer). For example when you are copying a big file on the worker thread and the percentage counter changes you can use PostMessage() to send a WM_APP+0 message with a wParam=percentage parameter. In your main window you handle the WM_APP+0 message (on your gui thread) and update your progressbar accordingly. Note that we used PostMessage() that put the message to the queue of the gui thread for later processing and PostMessage() returned immediately without unnecessarily waiting for the actual processing of the message on the gui thread (and the progressbur update) so as to prevent slowing down the worker thread. No need to wait for that progressbar update on the gui thread! A codeproject article that demonstrates the use of these thingies with MFC: Synchronization in Multithreaded Applications with MFC[^]
modified 4-Sep-12 20:30pm.
|
|
|
|
|
Good comment, but you may win an award for the most poorly formatted comment this year. 
|
|
|
|
|
Well, formatting has never been a strength of mine...
|
|
|
|
|
Yeah that was pretty painful
|
|
|
|
|
Try some better spacing, and use paragraphs; this is very hard on the eyes.
One of these days I'm going to think of a really clever signature.
|
|
|
|
|
pasztorpisti wrote: The less hassle free solution is sending a message from the worker thread to the ui thread by using SendMessage()...
What happens when the primary (UI) thread is blocked and the worker thread sends it a message via SendMessage()?
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"Show me a community that obeys the Ten Commandments and I'll show you a less crowded prison system." - Anonymous
|
|
|
|
|
Then the worker thread is waiting until the message is processed on the gui thread. Exploiting this you can for example pop up a messagebox from the worker thread by sending a WM_APP+X message to the gui thread that processes WM_APP+X and "blocks" until the message box is closed. The worker thread continues running only after the message box is closed and the processing of WM_APP+X is finished on the gui thread. I quoted "blocks" because a MessageBox call doesn't really block the gui thread, it just blocks the processing of a single message an it runs an inner messageloop of its own so processing other messages from the queue of the gui thread goes on. For example your windows are still drawn (by WM_PAINT messages) while a messagebox is active.
PS: The ui thread should never be blocked, that causes unresponsive UI. Often thats the reason for multithreading and not gaining performance. If your UI thread is blocked then your program is either buggy or poorly designed.
|
|
|
|
|
pasztorpisti wrote: Then the worker thread is waiting until the message is processed on the gui thread.
I'm not talking about the primary thread being busy for a few nanoseconds. I'm talking about deadlock. For example, the secondary thread sends a "add item to the control" message (e.g., LB_ADDSTRING) to the primary thread, which is blocked waiting on the secondary thread to complete. Now the secondary thread cannot complete because it is no longer running (waiting on SendMessage() to return). This is the primary reason why SendMessage() should rarely, if ever, be used to communicate between primary and secondary threads.
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"Show me a community that obeys the Ten Commandments and I'll show you a less crowded prison system." - Anonymous
|
|
|
|
|
The gui thread should never block, as a consequence it should never wait for the worker thread to complete. When the worker thread completes it can send/post a message to the gui thread to signal. Why would you want a blocking-wait on the gui thread???
|
|
|
|
|
SendMessage() is a blocking call... that's what he was pointing out.
|
|
|
|
|
DavidCrow wrote: For example, the secondary thread sends a "add item to the control" message
(e.g., LB_ADDSTRING) to the primary thread
This is the scenario that's confused me from time to time. It is really legal for a thread to do a SendMessage() to a control (the target of the LB_ADDSTRING) that is owned by another thread? I thought that Windows checked "thread ownership" of the control and returned an error on the SendMessage(). If the "primary thread" is, as is implied in your reply, the UI thread, then the "secondary thread" should not be allowed access to the control.
I've always used "PostMessage()" and used "user defined messages" to have secondary threads pass messages / commands to the primary thread for action. Since "PostMessage()" is just a queueing action, there is no deadlock (although you might not get the immediate feedback of a screen update).
Does anyone have the definitive answer on "SendMessage and Control Owner Thread" question?
|
|
|
|
|
That's a good question... I do believe the framework allows you to do it though... although now that you're questioning it, you're making me question whether I remember that correctly.
|
|
|
|
|
You know, some days I don't remember where my head is. Of course you can do it and, in fact, I do it all the time in certain apps. For example, if I have a "DO IT!" button, that usually creates a worker thread that does some stuff and updates a "log view" edit control in the main dialog. The GUI thread continues on and watches for the user clicking on "STOP DOING IT!".
Meanwhile, the worker thread does a
TheDialog->m_editcontrol.SetText(logbuffer); or something equivalent to update the subclassed edit window. Works just fine. I guess I forget this because the "SendMessage()" is buried in the SetText() function and not something I explicitly do but it is still "SendMessage()" from a thread that did not "own" or "create" the control.
Oh well, must be getting old.
|
|
|
|
|
Chuck O'Toole wrote:
Oh well, must be getting old.
Happens...
Yeah, as a rule of thumb though, I like to tell people to PostMessage() when doing things between threads (since they're supposed to be independent anyway). As you probably know, the synchronicity of SendMessage() has the potential for deadlocks so it should only be used when you truly need it.
|
|
|
|
|
Ok, instead of modifying my original question I will continue the thread since it has been really helpful. So, my program uses the following code to create a new thread.
m_Thread = AfxBeginThread(Acq_Data,this,THREAD_PRIORITY_HIGHEST);
This thread is told to look at the current class and the controlling function is Acq_Data. In Acq_Data there is the following code.
while(dlg->m_Continue && ! dlg->m_inst->m_Flags.Halt)
{
dlg->m_inst->ADCdbInquire(dlg->m_halfdata,hdlg,MSG_DRAW_SPECTRUM);
}The ADCdbInquire()function contains a call to PostMessage()
bool CPXI::ADCdbInquire(short *halfbuffer, HWND hwnd ,int Message)
{
short iStatus, iHalfReady, iDAQstopped = 0;
unsigned long ulPtsTfr=1500;
iStatus = DAQ_DB_HalfReady(m_6052_Device, &iHalfReady,
&iDAQstopped);
if ((iHalfReady == 1) && (iDAQstopped == 0))
{
iStatus = DAQ_DB_Transfer(m_6052_Device, halfbuffer,
&ulPtsTfr, &iDAQstopped);
NIDAQErrorHandler(iStatus, "DAQ_DB_Transfer",m_SuppressErrors);
if(Message != -1)
PostMessage(hwnd,WM_COMMAND,Message,NULL);
return true;
}
return false;
}
and is sending a custom message defined in the header file.
#define MSG_DRAW_SPECTRUM (WM_APP + 5) This custom messages refers to member function OnDrawSpectrum() where the following code exists to update the window.
void CDlg_SpectrumAnalyzer::OnDrawSpectrum()
{
int starti,finishi;
starti = m_datacount * m_BuffSize / 2;
finishi = (m_datacount + 1)* m_BuffSize / 2;
if(finishi > m_AcqNPts)
finishi = m_AcqNPts;
int j = 0;
for(int i = starti; i < finishi; i++)
{
m_fftdata[i].re = m_halfdata[j++];
m_fftdata[i].im = 0.;
}
m_datacount++;
if((m_datacount == m_NBuffs))
{
OnSpectrumStart();
float freq = 0;
float stepsize = ((float)(m_MaxFreq)) / ((float)(m_AcqNPts-1)/2.0);
m_datacount = 0;
m_Graph->ClearGraph(m_graphNum,false);
fftw_one(m_the_plan, m_fftdata, NULL);
for(int i = m_AcqNPts-1; i >= m_AcqNPts/2; i-= 1)
{
m_fftdata[i].re = sqrt(m_fftdata[i].re * m_fftdata[i].re +
m_fftdata[i].im * m_fftdata[i].im);
if(m_LogY)
m_fftdata[i].re = log(m_fftdata[i].re);
if(m_RtHz)
m_Graph->AddPoint(m_graphNum,sqrt(freq),m_fftdata[i].re,false);
else
m_Graph->AddPoint(m_graphNum,freq,m_fftdata[i].re,false);
freq += stepsize;
}
if(!m_LogY)
m_Graph->SetAxisProps(_T("Intensity"), _T("I"), 2, GRAPH_Y_AXIS,false);
else
m_Graph->SetAxisProps(_T("log Intensity"), _T("log(I)"), 2, GRAPH_Y_AXIS,false);
if(m_RtHz)
m_Graph->SetAxisProps(_T("Rt Frequency"), _T("Rt Hz"), 2, GRAPH_X_AXIS, false);
else
m_Graph->SetAxisProps(_T("Frequency"), _T("Hz"), 2, GRAPH_X_AXIS, false);
EnableItems(true);
m_Graph->UpdateWindows(GRAPH_WUV_ALL);
}
}
So, my question...in order to get this sequence to run several times, say 5 times, and update the window how would I use PostMessage()? Or if I have misunderstood something please let me know.
Thanks again for all the help.
|
|
|
|
|
AndrewG1231 wrote:
So, my question...in order to get this sequence to run several times, say 5 times, and update the window how would I use PostMessage()? Or if I have misunderstood something please let me know.
See here for more.
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"Show me a community that obeys the Ten Commandments and I'll show you a less crowded prison system." - Anonymous
|
|
|
|
|
Thanks for the link to the article and I have tried to implement the PostMessage() in my code.
However, I am still having problems trying to get it to execute more than once and update the window (looping the code is not working). After reading your suggested article, I am still not sure how to do this correctly, can you help?
My code is as follows.
void CDlg_SpectrumAnalyzer::OnBtnClickedRun()
{
PostMessage(WM_COMMAND,IDC_SPECTRUM_START,0);
}
Yes, this is a "Run" button that sends the message and it executes correctly if called only a single time.
|
|
|
|
|
AndrewG1231 wrote: ...it executes correctly if called only a single time.
What happens when the handler is called a second time?
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"Show me a community that obeys the Ten Commandments and I'll show you a less crowded prison system." - Anonymous
|
|
|
|
|
When it is called the second time I encounter some code for checking the state of the instrument my program is controlling. You can see the whole block of code this belongs to in the first post of this thread.
if(!m_inst->StartOperation())
{
MessageBox("The Instrument is Currently in use by another function");
return;
}I thought this indicated that the previous thread wasn't terminating before the message posted again and I tried to use Sleep() to delay the call, but this did not work. I encountered the same situation or the window did not update. I also tried to use the WaitForSingleObject(), but this failed as well.
|
|
|
|
|
Look this over. It's from memory and completly untested so there may be a few small details left out, but it should give you good idea of how primary and secondary threads communicate.
BEGIN_MESSAGE_MAP(CMyDialog, CDiaog)
ON_BN_CLICKED(IDC_BUTTON, OnClick)
END_MESSAGE_MAP()
void CMyDialog::Acq_Data( void )
{
while (1)
{
if (WaitForSingleObject(m_pEventStopRequested->m_hObject, 0U) == WAIT_OBJECT_0)
{
m_pEventThreadDone->SetEvent();
return;
}
else
ADCdbInquire(...);
}
}
UINT CMyDialog::Acq_Data( LPVOID lpVoid )
{
CMyDialog *pDlg = (CMyDialog *) lpVoid;
pDlg->Acq_Data();
return 0;
}
CWinThread *m_pThread = NULL;
CEvent *m_pEventStopRequested = new CEvent(FALSE, TRUE);
CEvent *m_pEventThreadDone = new CEvent(TRUE, TRUE);
void CMyDialog::OnClick()
{
if (WaitForSingleObject(m_pEventThreadDone->m_hObject, 0U) == WAIT_OBJECT_0)
{
m_pEventStopRequested->ResetEvent();
m_pEventThreadDone->ResetEvent();
m_pThread = AfxBeginThread(Acq_Data, this, THREAD_PRIORITY_HIGHEST);
}
}
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"Show me a community that obeys the Ten Commandments and I'll show you a less crowded prison system." - Anonymous
modified 13-Sep-12 9:44am.
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
