C++ Tricky Problem

[=?Utf-8?B?dGhlamFja29mYWxs?=]

I have a few global variables and a function that gets called multiple times
to complete a single transaction and uses the variables. The function gets
different notifications. When the function receives a final notification,
that where I need to release the global variables. I don't have control over
when the function gets called because the function is called by the system.
How can I block the function so that it can only be entered after the global
variables are released? Here is my code.

string sHeader;
string sData;

DWORD WINAPI __stdcall MyProc(...)
{
switch (NotificationTy pe)
{
case NOTIFICATION1:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION2:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION3:
{
// release here
...

break;
}
}
}


--
Be Cool!

[Chris Mullins [MVP - C#]]

[I'm torn. Is this a programming homework assignment or a real problem? I'll
lean towards the real problem on this one...]

What you're looking for is called Thread Synchronization . If you code is
Managed C++, you want to use the Monitor Class - specifically Monitor.Enter
and Montior.Exit. If you're in Win32 C++, you want to use a Critical
Section.

In both cases, make sure you use try/finally notation to make sure the
Monitor.Exit / LeaveCriticalSe ction are called even in exception cases.

Since your code looks link Win32 C++ (even though it's posed to a group
where Managed C++ is more common), I think your code will look like:

string sHeader;
string sData;
CriticalSection cs;

void GlobalVarialIni tialization()
{
InitializeCriti calSection(&cs) ;
}

DWORD WINAPI __stdcall MyProc(...)
{
EnterCriticalSe ction(&cs);
__try
{
switch (NotificationTy pe)
{
...
}
}
__finally
{
LeaveCriticalSe ction(cs);
}

(It's been a while since i wrote C++ code. Forgive me if I goofed anything
silly...)

--
Chris Mullins

"thejackofa ll" <th**********@d iscussions.micr osoft.comwrote in message
news:FD******** *************** ***********@mic rosoft.com...

>I have a few global variables and a function that gets called multiple
times
to complete a single transaction and uses the variables. The function
gets
different notifications. When the function receives a final notification,
that where I need to release the global variables. I don't have control
over
when the function gets called because the function is called by the
system.
How can I block the function so that it can only be entered after the
global
variables are released? Here is my code.

string sHeader;
string sData;

DWORD WINAPI __stdcall MyProc(...)
{
switch (NotificationTy pe)
{
case NOTIFICATION1:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION2:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION3:
{
// release here
...

break;
}
}
}


--
Be Cool!

[=?Utf-8?B?dGhlamFja29mYWxs?=]

Chris,

I appreciate your reply. Now, the problem is that the function gets called
many times to work on the global variables to complete a single transaction.
And, if you look at my code, the only location I can leave the critical
section is when NotificationTyp e is SF_NOTIFY_END_O F_SESSION. It would have
to be something like below, but I doubt that it would work. And, I don't
have control over when MyProc() is called or how it's called. I just know
that it can be called many times to process a single request.

CRITICAL_SECTIO N cs;
string sHeader;
string sData;

DWORD WINAPI __stdcall MyProc(...)
{
EnterCriticalSe ction(&cs);

switch (NotificationTy pe)
{
case NOTIFICATION1:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION2:
{
// do something here with sHeader and sData
...

break;
}

case SF_NOTIFY_END_O F_SESSION:
{
// release here
...
LeaveCriticalSe ction(&cs);

break;
}
}
}
--
Be Cool!
"Chris Mullins [MVP - C#]" wrote:

[I'm torn. Is this a programming homework assignment or a real problem? I'll
lean towards the real problem on this one...]

What you're looking for is called Thread Synchronization . If you code is
Managed C++, you want to use the Monitor Class - specifically Monitor.Enter
and Montior.Exit. If you're in Win32 C++, you want to use a Critical
Section.

In both cases, make sure you use try/finally notation to make sure the
Monitor.Exit / LeaveCriticalSe ction are called even in exception cases.

Since your code looks link Win32 C++ (even though it's posed to a group
where Managed C++ is more common), I think your code will look like:

string sHeader;
string sData;
CriticalSection cs;

void GlobalVarialIni tialization()
{
InitializeCriti calSection(&cs) ;
}

DWORD WINAPI __stdcall MyProc(...)
{
EnterCriticalSe ction(&cs);
__try
{
switch (NotificationTy pe)
{
...
}
}
__finally
{
LeaveCriticalSe ction(cs);
}

(It's been a while since i wrote C++ code. Forgive me if I goofed anything
silly...)

--
Chris Mullins

"thejackofa ll" <th**********@d iscussions.micr osoft.comwrote in message
news:FD******** *************** ***********@mic rosoft.com...

I have a few global variables and a function that gets called multiple
times
to complete a single transaction and uses the variables. The function
gets
different notifications. When the function receives a final notification,
that where I need to release the global variables. I don't have control
over
when the function gets called because the function is called by the
system.
How can I block the function so that it can only be entered after the
global
variables are released? Here is my code.

string sHeader;
string sData;

DWORD WINAPI __stdcall MyProc(...)
{
switch (NotificationTy pe)
{
case NOTIFICATION1:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION2:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION3:
{
// release here
...

break;
}
}
}


--
Be Cool!

[Chris Mullins [MVP - C#]]

I somehow missed that in your use case.

The Critical Section here will cause you no end of problems if used that
way.

It seems like it's time for you to start on a new internal algorithm....

--
Chris Mullins
"thejackofa ll" <th**********@d iscussions.micr osoft.comwrote in message
news:84******** *************** ***********@mic rosoft.com...

Chris,

I appreciate your reply. Now, the problem is that the function gets
called
many times to work on the global variables to complete a single
transaction.
And, if you look at my code, the only location I can leave the critical
section is when NotificationTyp e is SF_NOTIFY_END_O F_SESSION. It would
have
to be something like below, but I doubt that it would work. And, I don't
have control over when MyProc() is called or how it's called. I just know
that it can be called many times to process a single request.

CRITICAL_SECTIO N cs;
string sHeader;
string sData;

DWORD WINAPI __stdcall MyProc(...)
{
EnterCriticalSe ction(&cs);

switch (NotificationTy pe)
{
case NOTIFICATION1:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION2:
{
// do something here with sHeader and sData
...

break;
}

case SF_NOTIFY_END_O F_SESSION:
{
// release here
...
LeaveCriticalSe ction(&cs);

break;
}
}
}
--
Be Cool!
"Chris Mullins [MVP - C#]" wrote:

>[I'm torn. Is this a programming homework assignment or a real problem?
I'll
lean towards the real problem on this one...]

What you're looking for is called Thread Synchronization . If you code is
Managed C++, you want to use the Monitor Class - specifically
Monitor.Ente r
and Montior.Exit. If you're in Win32 C++, you want to use a Critical
Section.

In both cases, make sure you use try/finally notation to make sure the
Monitor.Exit / LeaveCriticalSe ction are called even in exception cases.

Since your code looks link Win32 C++ (even though it's posed to a group
where Managed C++ is more common), I think your code will look like:

string sHeader;
string sData;
CriticalSectio n cs;

void GlobalVarialIni tialization()
{
InitializeCriti calSection(&cs) ;
}

DWORD WINAPI __stdcall MyProc(...)
{
EnterCriticalSe ction(&cs);
__try
{
switch (NotificationTy pe)
{
...
}
}
__finally
{
LeaveCriticalSe ction(cs);
}

(It's been a while since i wrote C++ code. Forgive me if I goofed
anything
silly...)

--
Chris Mullins

"thejackofal l" <th**********@d iscussions.micr osoft.comwrote in message
news:FD******* *************** ************@mi crosoft.com...

>I have a few global variables and a function that gets called multiple
times
to complete a single transaction and uses the variables. The function
gets
different notifications. When the function receives a final
notification,
that where I need to release the global variables. I don't have
control
over
when the function gets called because the function is called by the
system.
How can I block the function so that it can only be entered after the
global
variables are released? Here is my code.

string sHeader;
string sData;

DWORD WINAPI __stdcall MyProc(...)
{
switch (NotificationTy pe)
{
case NOTIFICATION1:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION2:
{
// do something here with sHeader and sData
...

break;
}

case NOTIFICATION3:
{
// release here
...

break;
}
}
}


--
Be Cool!