Is there any memory leak between two threads (Buffering, Emptying) - c++

Question

Consider the following code please, including two threads buffering_thread (fills up buffer pointer with one message) and sending_thread (empties the buffer):
#include "msg.cpp"
msg * buffer= NULL;
byte * send_bytes= NULL;
bool keep_buffering = true;
bool keep_sending = true;
int counter = 0;
void start_buffering() {
while (keep_buffering){
while (buffer != NULL && keep_buffering){}
msg m (counter);
buffer = &m;
counter ++;
}
std::cout << "Finished start_buffering" << std::endl;
}
void sending() {
while (keep_sending){
if (counter > 10){
keep_buffering = false;
break;
}
if (buffer != NULL){
HeaderType messageHeader = buffer -> getHeader();
print(messageHeader);
send_bytes = (byte *) realloc(send_bytes,DATASIZE + HEADER);
memcpy (send_bytes, &messageHeader, HEADER);
memcpy (send_bytes + HEADER,buffer -> getText(), DATASIZE);
// Do something, suppose for now NOTHING
free (buffer -> getText());
buffer = NULL;
}
}
std::cout << "Finished sending" << std::endl;
}
int main () {
std::thread sending_thread(sending);
std::thread buffering_thread(start_buffering);
buffering_thread.join();
keep_sending = false;
sending_thread.join();
//free (buffer);
free (send_bytes);
return 0;
}
where the class msg is as follows:
#include <iostream>
#include <stdlib.h>
#include <cstring>
#include <mutex>
#include <thread>
#define DATASIZE 10
#define HEADER sizeof(HeaderType)
class msg
{
private:
HeaderType header;
byte * text;
public:
msg(int ID);
HeaderType getHeader();
byte * getText();
};
msg::msg(int ID){
header.mID = ID;
text = (byte *)malloc (DATASIZE);
memset (text, '.', DATASIZE);
}
HeaderType msg::getHeader(){
return header;
}
void print(HeaderType header) {
std::cout << "Message ID: " << header.mID << std::endl;
}
byte * msg::getText(){
return text;
}
and this is HeaderType:
typedef struct {
int mID;
}HeaderType;
Valgrind reports:
==3809== 20 bytes in 2 blocks are definitely lost in loss record 1 of 1
==3809== at 0x4028876: malloc (vg_replace_malloc.c:236)
==3809== by 0x80492BD: msg::msg(int) (in /home/linux/LCR-write/src/test)
==3809== by 0x8049384: start_buffering() (in /home/linux/LCR-write/src/test)
Indeed, I guess there must not be any memory leak inside this code. The buffer should always be emptied by sending_thread. Would somebody point out the fault please.

Answer 1

The problem is in the start_buffering() function.
while (keep_buffering){
msg m (counter);
while (buffer != NULL && keep_buffering){}
buffer = &m;
counter ++;
}
This loop creates a msg and allocates the memory for text in it's constructor. Then it waits, and then it will do:
buffer = &m;
counter ++;
// end of loop
msg m (counter);
When the loop reaches the end, it starts the next iteration without waiting for anything. The 'old' msg m falls out of scope, and a new msg m is allocated at the exact same place on the stack than the old one. So the pointer buffer is still 'valid' (not really!), pointing to the new m. The result is a memory leak for the first msg m, and, more importantly, undefined behaviour. You may not use things that are not in scope anymore.
Additionally, I would recommend to use 'official' synchronisation and wait mechanisms.

Answer 2

you need a destructor for msg that frees the memory allocated for text in the constructor
class msg
{
private:
HeaderType header;
byte * text;
public:
msg(int ID);
HeaderType getHeader();
byte * getText();
~msg() {free(text);}
};