Seg. fault in Multithreaded UDP server - c++

Question

Background:
I have a UDP server that can process clients' requests concurrently. Each client sends two datagrams to the server.
First datagram (Type - 1, Client num)
Second datagram (Type - 2, Client num)
To process all clients concurrently, I initially create a fixed number of server threads and one global UDP socket bound to a known port/address. Then each thread starts to run wherein they block on recvfrom() call on the same global socket. Whichever thread receives a datagram first checks
the type. If it is type 1, it generates a "special" number for the client num it received and stores it. It it is type 2, it sends back the stored "special" number for that client.
Server program:
#define SIZE 1024
int status;
int tnum;
int i;
vector<pthread_t> tid;
struct sockaddr_in server_sock_addr;
const char *server_addr = "127.0.0.1";
int sock;
int reuse = 1;
socklen_t addr_len = sizeof(sockaddr_in);
unordered_map<int, int> dic;
void report(int status){
if(status < 0){
perror("Error");
exit(EXIT_FAILURE);
}
}
void* server_func(void *arg){
int bytes;
char *buf = (char*)malloc(SIZE);
struct sockaddr_in client_sock_addr;
int type;
int num;
while(1){
bytes = recvfrom(sock, buf, SIZE, 0, (sockaddr*)&client_sock_addr, &addr_len);
cout<<bytes<<endl;
report(bytes);
memmove(&type, buf, sizeof(int));
memmove(&num, buf + sizeof(int), sizeof(int));
if(type == 1){
dic[num] = num * 1000;
}
else if(type == 2){
while(dic.find(num) == dic.end()){
};
memset(buf, 0, SIZE);
memmove(buf, &dic[num], sizeof(int));
status = sendto(sock, buf, sizeof(int), 0, (sockaddr*)&client_sock_addr, addr_len);
report(status);
cout<<"Mapped number is "<<num<<" - "<<dic[num]<<endl;
}
else{
report(-1);
}
}
free(buf);
}
int main() {
cout<<"-------------------------------------------"<<endl;
cout<<"SERVER STARTED on port 5000"<<endl;
cout<<"-------------------------------------------"<<endl;
tnum = 4;
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
bzero((char*)&server_sock_addr, sizeof(server_sock_addr));
server_sock_addr.sin_family = AF_INET;
server_sock_addr.sin_port = htons(5000);
inet_aton(server_addr, &server_sock_addr.sin_addr);
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int));
status = bind(sock, (struct sockaddr*)&server_sock_addr, sizeof(server_sock_addr));
report(status);
tid.resize(tnum);
dic.clear();
for (i = 0; i < tnum; i++) {
status = pthread_create(&tid[i], NULL, server_func, NULL);
report(status);
}
for (i = 0; i < tnum; i++) {
pthread_join(tid[i], NULL);
}
close(sock);
return 0;
}
Client program
#define SIZE 1024
int num;
int i;
vector<pthread_t> tid;
vector<int> client_num;
const char *server_addr = "127.0.0.1";
socklen_t addr_len = sizeof(sockaddr_in);
void report(int status){
if(status < 0){
perror("Error");
exit(EXIT_FAILURE);
}
}
void* client_func(void *arg){
struct sockaddr_in server_sock_addr;
int cnum = *((int*)arg);
char *buf = (char*)malloc(SIZE);
int type;
int sock;
int bytes;
int status;
int res;
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
bzero((char*)&server_sock_addr, sizeof(server_sock_addr));
server_sock_addr.sin_family = AF_INET;
server_sock_addr.sin_port = htons(5000);
status = inet_aton(server_addr, &server_sock_addr.sin_addr);
report(status);
type = 1;
memset(buf, 0, SIZE);
memmove(buf, &type, sizeof(int));
memmove(buf + sizeof(int), &cnum, sizeof(int));
status = sendto(sock, buf, 2 * sizeof(int), 0, (sockaddr*)&server_sock_addr, addr_len);
report(status);
type = 2;
memset(buf, 0, SIZE);
memmove(buf, &type, sizeof(int));
memmove(buf + sizeof(int), &cnum, sizeof(int));
status = sendto(sock, buf, 2 * sizeof(int), 0, (sockaddr*)&server_sock_addr, addr_len);
report(status);
bytes = recvfrom(sock, buf, SIZE, 0, (sockaddr*)&server_sock_addr, &addr_len);
report(bytes);
memcpy(&res, buf, sizeof(int));
cout<<"Mapped number from the server for Client - "<<cnum<<" is "<<res<<endl;
free(buf);
close(sock);
}
int main(int argc, char *argv[]) {
int status;
if(argc < 2){
cout<<"Enter number of threads"<<endl;
exit(EXIT_FAILURE);
}
num = atoi(argv[1]);
tid.resize(num);
client_num.resize(num);
for (i = 0; i < num; i++) {
client_num[i] = i+1;
status = pthread_create(&tid[i], NULL, client_func, &client_num[i]);
}
for (i = 0; i < num; i++) {
pthread_join(tid[i],NULL);
}
cout << "Requested duration has ended. Finishing the program." << endl;
return 0;
}
Problem I am facing:
When 500 clients send datagrams concurrently, the server works as expected only when I include some kind of COUT statement after the recvfrom() call(First line in while(1) loop). If I delete that cout statement, it gives Segmentation fault because the server gets stuck on the while() loop to check whether an item exists or not. while(dic.find(num) == dic.end()){};. I am not able to figure out the reason for this problem. Please provide me your suggestions.
Thanks.
EDIT:
Having a mutex lock on "dic" data-structure(while writing it) solves the problem(I do not need to use "cout" anymore), but I want to confirm whether this is absolutely the correct fix and want to learn anyother subtle points that I could out of this program, because I'd building a much bigger version of this program soon with lots of global datastructures to be shared by all threads