C / C++ / MFC

21-Apr-06 23:27

So far I have had everything working without a hitch, right up until I introduced threads to my projects. Let me explain what I am doing. I create a class which opens a CompoundFile using ole2's IStorage and Istream. The class then creates another class object passing along the Istream pointer.

This new class then creates a clone of the stream and launches a thread from where the stream should be read. The cloned copy is stored as a class member, before the thread is launched the seek pointer is set and there are no problems. The thread function is a static class member and I have enabled the access to the rest of the class by passing the this pointer.

The problem is here from inside the thread

long hr = 0;
hr = stream->Read(&_id,2,&s);
if (FAILED(hr)) {
    printf("Read stream failed");
}
stream->Read(&_ssz,2,&s);

The program throws an 'Access Error' when trying to read. The address of the stream is correct, but the IUnknown members of the stream are not.

This is the code I used to initialy open the document and stream, I have a feeling the problem is here somewhere.

// Open the document as an OLE compound document.
hr = ::StgOpenStorage(wcFilename, NULL,STGM_READ|STGM_SHARE_DENY_WRITE , NULL, 0, &pStorage);
if(FAILED(hr)) {
    if(hr == STG_E_FILENOTFOUND)
        printf("File not found.");
    else if(hr == STG_E_FILEALREADYEXISTS)
        printf("Not a compound file.");
    else
        printf("StgOpenStorage() failed w/error %08lx", hr);
    return;
}
hr = pStorage->OpenStream(L"Workbook",NULL,NULL,STGM_READ|STGM_SHARE_EXCLUSIVE|STGM_DIRECT,NULL,&pStream);
if(FAILED(hr)) {
    printf("Open stream failed");
    pStorage->Release();
    return;
}

Stephen Hewitt22-Apr-06 0:32

22-Apr-06 0:32

I would need to see the code for the thread you spawn and the code which spawns it. Do you realize that you can't just use an interface pointer created in one thread in another thread without marshaling it to the new thread? Are you performing marshalling?

Steve

Waldermort22-Apr-06 0:46

22-Apr-06 0:46

I have just realised that that is probably what I have done wrong. At the moment I am trying to find out how to implement Marshaling. My first attempt is this

long hr = CoMarshalInterThreadInterfaceInStream(IID_IStream,NULL,&_stream);<pre>which is returning -2147024809.

Stephen Hewitt22-Apr-06 1:08

22-Apr-06 1:08

Here's one way to do it:
------------------------
IStream *pMarshalData;
HRESULT hr = CoMarshalInterThreadInterfaceInStream(IID_IStream, pStream, &pMarshalData);
if ( SUCCEEDED(hr) )
{
// Spawn your new thread here. Pass it the pMarshalData pointer.
}

// In the spawned thread somewhere.
IStream *pStream;
HRESULT hr = CoGetInterfaceAndReleaseStream(pMarshalData, IID_IStream, reinterpret_cast<void**>(&pStream));
if ( SUCCEDED(hr) )
{
// Use pStream.
pStream->Release();
}
------------------------

The astute reader may notice that we're using "pMarshalData" in another thread without marshalling. This is OK as the object returned by this API is free threaded.

Steve

Waldermort22-Apr-06 1:58

22-Apr-06 1:58

Using your suggestion

IStream *pMarshalData;
HRESULT hr = CoMarshalInterThreadInterfaceInStream(IID_IStream, NULL, &pMarshalData);
if ( SUCCEEDED(hr) )
{
    // start my thread
}

This is returning -2147221008.

Stephen Hewitt22-Apr-06 2:01

22-Apr-06 2:01

That is not my suggestion. This was:

HRESULT hr = CoMarshalInterThreadInterfaceInStream(IID_IStream, pStream, &pMarshalData);

pStream is your stream. As my sample code shows you have to unmarshall at the other end before you can use your stream.

Steve

Waldermort22-Apr-06 2:14

22-Apr-06 2:14

_stream is my stream, the only difference is that it is a class member.

-- modified at 8:17 Saturday 22nd April, 2006

Eek, sorry, I just noticed what you mean. I incorrectly pasted the wrong code snippet, the second paramater should not be NULL it should be _stream. After trying the first time I changed the paramaters a little, my appologies.

Waldermort22-Apr-06 2:41

22-Apr-06 2:41

Problem solved, I was neglecting to call CoInitialize(). Thanks for your help.

Waldermort22-Apr-06 3:36

22-Apr-06 3:36

Well I thought I had this working, but it seems that the CoGetInterfaceAndReleaseStream function is entering into an endless loop and not returning. This is of course causing any following code not to be executed, and later my WaitForMultipleObjects does just that and waits.

_stream = NULL;
HRESULT hr = CoGetInterfaceAndReleaseStream(_marshal,
IID_IStream, (void **)&_stream);
if ( FAILED(hr) )
{
    return;
}

Is it possibly related to the initial flags when opening the stream? I have tried changing them but it only leads to the stream failing to open.

Stephen Hewitt22-Apr-06 3:51

22-Apr-06 3:51

waldermort wrote:
Is it possibly related to the initial flags when opening the stream?

I'd say no.

He's something for you to try. Place the following debugging code after you spawn your thread and marshal the stream:

// Spawn the thread and marshal here.
MSG m;
while ( GetMessage(&m, NULL, 0, 0) )
{
    DispatchMessage(&m);
}

If this code stops CoGetInterfaceAndReleaseStream from hanging it is probably because your STA apartment isn't playing by the rules and running a message pump.

Steve

Waldermort22-Apr-06 4:08

22-Apr-06 4:08

Wow, you really know your stuff. You were right adding the code after spawning the thread stopped it from hanging. So I guess my question is, why is it not playing by the rules? I thought that when COM creates an STA it also creates a message loop.

Stephen Hewitt22-Apr-06 4:26

22-Apr-06 4:26

waldermort wrote:
I thought that when COM creates an STA it also creates a message loop

You created this STA - it's up to you to run message loops - It can be no other way as COM has no way of knowing when it's safe to do so.

When you marshal the stream pointer to the other thread what you're really doing is setting up a communication channel from the worker thread to the main thread. When you call a stream function in the worker thread COM has to get the main thread to call into the stream object and the worker thread waits till the main thread makes the call. Once the main thread is done it sends the data to the worker thread and both continue on their merry ways. But how can COM know when it's safe to hijack the main thread and make a call into the stream on behalf of the worker thread? It's different for all the threading models but for a STA this happens when you run a message pump. To make all this happen COM needs to setup a proxy in the worker thread and a stub in the main thread. This is what COM was trying to do when your code hung. More specifically it was trying to get the main thread to do its part and setup the stub but it needs it to run a message pump.

Also, as you may see based on this description, even though you have multiple threads any call into the stream from the worker thread actually gets the main thread to do the work. You may actually lose performance. Do you really need multiple threads?

Steve

Waldermort22-Apr-06 4:42

22-Apr-06 4:42

Stephen Hewitt wrote:
Do you really need multiple threads?

The stream I am reading can be broken into 8 sections (it's a 1mb file). To read the whole stream without threading takes appx. 18 seconds. I'm hoping to increase this speed by reading each section in a thread. I have coded it in such a way that whether to use threads can be defined before the file is opened.

Waldermort22-Apr-06 6:23

22-Apr-06 6:23

Well, I must say enabling the use of threads was a waste of 2 days. Performance went from 18 seconds to just over 30 seconds. The only alternative I can see is to copy the main stream into a buffer and split it into the individual sections. Which would a total waste of time and memory.

Stephen Hewitt22-Apr-06 1:19