Merge sort between 2 file with thread

[Franconet]

// mergefile2norecreation.cpp : definisce il punto di ingresso dell'applicazione console.
//
// Filemerge.cpp : definisce il punto di ingresso dell'applicazione console.
//

#include "stdafx.h"


int _tmain(int argc, _TCHAR* argv[])
{

TCHAR inputfile1[MAX_PATH];
TCHAR inputfile2[MAX_PATH];
TCHAR outputfile[MAX_PATH];
 
 
std::ifstream f1;
std::ifstream f2;
int flag1=1;
int flag2=1;

std::string s1;
std::string s2;

//se false , il consumatore deve scriverle
bool b1=FALSE;
bool b2=FALSE;



std::mutex m1;
std::mutex m2;
std::mutex m3;

std::condition_variable cv1;
std::condition_variable cv2;
std::condition_variable cv3;
 





 

_tcscpy_s(inputfile1,MAX_PATH,argv[1]);
_tcscpy_s(inputfile2,MAX_PATH,argv[2]);
_tcscpy_s(outputfile,MAX_PATH,argv[3]);

f1.open(inputfile1);
f2.open(inputfile2);


/*
Thread behavior is 

*get lock 
*produce string
* signal to consumer 
* wait until consumer will signal you 

*/
 


 
std::thread t1([&f1,&s1,&m1,&cv1,&b1,&cv3]()->void{
 while(1){
	std::unique_lock<std::mutex> ul1(m1);
	if(f1.good()) { 
	std::getline(f1,s1);
	}else {s1.clear(); }


	b1=true;
	cv3.notify_all();

	if(s1.empty()) {
		break;}

        while(b1==true)    cv1.wait(ul1);
		continue;
	} 
 
	 return;
 }
);

 
 
std::thread t2([&f2,&s2,&m2,&cv2,&b2,&cv3]()->void{

 while(1){
	std::unique_lock<std::mutex> ul2(m2);
	if(f2.good()) { 
	std::getline(f2,s2);
	}else{
	s2.clear();
	
	}

	b2=true;
    cv3.notify_all();

	if(s2.empty()){ 
		break;}

	while(b2==true)	cv2.wait(ul2); 
	
	}


	return ;
   



});

 


/*
Reader behavior is 

* get lock  of both thread!
* consume a string
* unlock only the thread for wich i have consumed the string 
*  
* wait that the victim thread produce something
* and repeat 

*/
 
 
 
 




while (1){ 

	{
 
  std::unique_lock<std::mutex> ul1(m1);
  while(b1==false) cv3.wait(ul1);

  std::unique_lock<std::mutex> ul2(m2);
  while(b2==false) cv3.wait(ul2);



if((s1.compare(std::string())==0) &&  (s2.compare(std::string())==0)){ break;  }

if(s1.compare(std::string())==0){  b2=false;  std::cout<<s2<<std::endl;   }
if(s2.compare(std::string())==0){  b1=false;   std::cout<<s1<<std::endl;    }

if(s1.compare(s2)<0   &&  s2.compare(std::string())!=0  &&  (s1.compare(std::string())!=0) )  {   
   b1=false; 
	std::cout<<s1<<std::endl;  }


if(s1.compare(s2)>=0  && s2.compare(std::string())!=0  &&  (s1.compare(std::string())!=0)) {  
   b2=false; 
	std::cout<<s2<<std::endl; 
} 
}
	cv1.notify_all();
	cv2.notify_all();



}


t1.join();
t2.join();


 

  
	  
	return 0;
}

Hi, There is a smart way to make a merge sort between 2 file already ordered?
I had try it ,and above there is my result,it works but i think that it's possible to do it in a smart way...

Thanks in advance

[MiiNiPaa]

Hi, There is a smart way to make a merge sort between 2 file already ordered?

What do you mean "ordered"? They contain some data which is ordered (say tuples of int, double, string)? And where do you want to store result of sorting? Another file? Overwrite content of some file?

Assuming you have an class data which represents data containing in files for which operators >> and << for reading from and saving to stream and also operator < for comparsion are defined and your files sorted ascending:

std::ifstream  ifirst("first_input.txt");
std::ifstream isecond("second_input.txt");
std::ofstream  output("output.txt");
std::merge(std::istream_iterator<data>(ifirst),  std::istream_iterator<data>(),
           std::istream_iterator<data>(isecond), std::istream_iterator<data>(),
           std::ostream_iterator<data>(output)  );

[Franconet]

Hi first of all , thans for your help.
This is the problem :

I have 2 file that contain a set of words.
In these file the word are in ascending order.
for example

File 1:

america
banana 
cactus
zebra

File 2:

red
tiger

The output file will be :

america
banana 
cactus
america
banana 
cactus
zebra
zebra

But i want to perform it with the thread...
A thread for each file .
The consumer riceve 2 string( 1 from each thread) , compare them

if the first is the bigger one consume it and ask to thread1 to produce another string.

if the second is the bigger one consume it and ask to thread2 to produce another string.

till the 2 file will end.

[MiiNiPaa]

I must warn you that you won't get any perfomance boost by using threads here and actually will suffer perfomance loss: you have natural bottleneck — IO. Hard disc cannot work concurrently. Also your threads should be synchronized and that will take its toll on resources.

[Franconet]

Yes sure,but it is not a real problem..is an exercises.
thanks :)