Quick query regarding pointer to struct and heapalloc in C++...

[n_K]

Got a quick C++ question here, tl;dr version is: Got a struct with some objects, creating a new array of objects, using heapalloc (which I thought would be similar to initialising them all manually, I can access/change VarB and VarC but whatever I try to do with VarA causes exception nightmare)

Long version: I've got a struct;

typedef struct ThreadSocketData
{
	list<SOCKET*> VarA;
	unsigned int VarB;
	unsigned int VarC;
} THREADSOCKETDATA, *PTHREADSOCKETDATA;

I'm allocating it as a global and in a function as;

PTHREADSOCKETDATA *pDataArrays;
...
pDataArrays = new PTHREADSOCKETDATA[2];
...
pDataArrays[i] = (PTHREADSOCKETDATA)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(THREADSOCKETDATA));

Then I try to use it like so;

pDataArrays[1]->VarB = 5;
cout << pDataArrays[1]->VarB << endl; //works fine
SOCKET *ASocket = new SOCKET;
*ASocket = 5;
pDataArrays[0]->VarA.push_back(ASocket); //exception crazy

I've tried created it alternatively and like so and it seems to work fine;

pDataArrays = new PTHREADSOCKETDATA[2];
pDataArrays[0] = new THREADSOCKETDATA;
pDataArrays[1] = new THREADSOCKETDATA;
pDataArrays[0]->VarC = 5;
pDataArrays[0]->VarB = 4;
pDataArrays[0]->VarA.begin();
SOCKET *ASocket = new SOCKET;
*ASocket = 18;
pDataArrays[0]->VarA.push_back(ASocket);

So why does the second way work but the first doesn't fully work? Surely using heapalloc would have the same effect as manually allocating it all?

[Andre S. Veteran]

Operator new calls constructors, malloc/HeapAlloc don't. My guess is that in your first example, VarA is uninitialized because its constructor hasn't run, so you cannot use it.

This would all be moot if you were using C++ idioms rather than mixing C idioms in there. In C++ you use new and delete, not malloc, unless you're implementing an allocator or something. Actually, scratch that, in modern C++ you don't even write new and delete, you use smart pointers and containers (see for instance http://fr.slideshare.net/sermp/without-new-and-delete ). In your example if you replace all the C-style arrays with std::vector, and all the raw pointers with smart pointers, every constructor and destructor is guaranteed to run exactly when it should and you shouldn't be leaking anything or accessing uninitialized state.

Also, as a matter of style you don't need to write typedef struct MyType {} MYTYPE in C++, just struct MYTYPE {}, and you'd probably want to avoid SCREAMINGCAPS for all your type names if you don't want your code to look like 9-year olds having an internet argument.

[n_K]

This is my first program with threading (not done it before) so I've been modifying the sample MSDN code which had it all in caps, not my idea of naming but good idea, I'll change that.

I don't think I can use smart pointers for this though? The pDataArray {i} is sent by reference to thread {i} although I want to be able to manipulate it from within the main thread therefore I left the heapalloc code as it was provided by MS, so if I remove all the heapalloc/heapfree and just use normal new/delete and pass that in CreateThread() it will work?

[Andre S. Veteran]

Do you really need to use the Win32 function CreateThread rather than standard C++ threads? 

[n_K]

  On 28/10/2015 at 21:08, Andre S. said:

Do you really need to use the Win32 function CreateThread rather than standard C++ threads? 

Well the problem is I'm making this program across 3 different types of PCs, my home PC has visual studio 2015 so std::thread is fine, I already use it to get the number of CPUs, another has visual studio 2013 and I'm not sure if it fully has std::thread or only parts of it? And the other has visual studio 2010, which doesn't have any std::thread support at all :(.

Using std::thread I can then pass it smart pointers or references to objects I manually new/delete and access them from the thread and main program? Also is there a std:: replacement for Createevent/Resetevent/Setevent/Waitformultipleobjects?

[Andre S. Veteran]

VS2015 Community Edition is free

Yes you can pass any object to an std::thread, look at the documentation. For a ManualResetEvent or AutoResetEvent you could implement that pretty straightforwardly with std::condition_variable and std::mutex, there are examples online.

 

[BannanaNinja]

I used std::thread in VS 2013 for my Windows Store app but +1 to the free VS 2015.

[DevTech]

  On 28/10/2015 at 21:24, n_K said:

Well the problem is I'm making this program across 3 different types of PCs, my home PC has visual studio 2015 so std::thread is fine, I already use it to get the number of CPUs, another has visual studio 2013 and I'm not sure if it fully has std::thread or only parts of it? And the other has visual studio 2010, which doesn't have any std::thread support at all :(.

Using std::thread I can then pass it smart pointers or references to objects I manually new/delete and access them from the thread and main program? Also is there a std:: replacement for Createevent/Resetevent/Setevent/Waitformultipleobjects?

Like everyone says - VS2015 freebie - no need to be complicated

But you never said what sort of code you are making. If it's anything connected with Device drivers then the std stuff is out the window...

[n_K]

I've got VS 2015 community on this pc which is fine - it's my PC. The other two PCs are not mine, they're in an educational establishment, I'm not administrator so I can't just install VS 2015 on them and why I have to put up with using 2010 and 2013 also.

I'll see if I can get a portable mingw working on the other PCs and see what happens if I chuck the code at that instead of using 2010 and 2013!

Nope not drivers, just testing out threads and winsock and the like. I've not looked into drivers, can MS drivers use multiple threads (even if not using std::thread threads)? Can Linux modules use threads (using std::thread)?

Thanks!

[simplezz]

It's a bad idea to mix allocation techniques like that unless you know what you're doing and it's for a good reason. In particular, STL data structures (such as list) only get initialised properly if you use the built-in new() operator to allocate them.

You might be able to get around it by calling new() on VarA after allocating the structure with malloc().

static const int ARRAY_SIZE = 20
THREADSOCKETDATA* myArray = malloc(ARRAY_SIZE * sizeof(THREADSOCKETDATA));

for (int i = 0; i < ARRAY_SIZE; i++)
    myArray[i].VarA = new list<SOCKET*>;
    
// clean up    
free(myArray);

I wouldn't recommend it though.

For efficiency purposes, I'd also allocate the entire array as a contiguous block of memory, rather than making multiple heap allocations for each individual structure.

[DevTech]

  On 29/10/2015 at 15:39, n_K said:

I've got VS 2015 community on this pc which is fine - it's my PC. The other two PCs are not mine, they're in an educational establishment, I'm not administrator so I can't just install VS 2015 on them and why I have to put up with using 2010 and 2013 also.

I'll see if I can get a portable mingw working on the other PCs and see what happens if I chuck the code at that instead of using 2010 and 2013!

Nope not drivers, just testing out threads and winsock and the like. I've not looked into drivers, can MS drivers use multiple threads (even if not using std::thread threads)? Can Linux modules use threads (using std::thread)?

Thanks!

Threads are easy to make. After that it can get interesting. There is a reason why just about every GUI system is limited to single-threaded.

If you are doing a real device driver for hardware then you have interrupts in which you need to store whatever you need within 30 millisecs and then Queue up worker threads to do the real processing which are also time limited so you then can have long running threads to process stuff as a background service. You need to be very aware of which variables are atomic and which data structures can get clobbered by your interrupt code, your DPC code, your worker thread etc. The killer is multi-core because it's so fast. It can look like impossible things happen like only 1/2 of a store to memory etc but then it turns out that compiler operation wasn't atomic...

The solution most people use is locks. After you do some device driver stuff, you learn to strike a more delicate balance. So learn what's atomic and every O/S has O/S API calls for safe atomic updates I think.