Monthly Archives: October 2013
C++ || Snippet – Custom Template “ToString” Function For Primitive Data Types
The following is a custom template “ToString” function which converts the value of a primitive data type (i.e: int, double, long, unsigned, char, etc.) to an std::string. So for example, if you wanted to convert an integer value to an std::string, the following function can do that for you.
This function works by accepting a primitive datatype as a function parameter, then using the std::stringstream class to convert and return an std::string object containing the representation of that incoming function parameter as a sequence of characters.
The code demonstrated on this page is different from the std::to_string function in that this implementation does not require a compiler to have >= C++11 support. This function should work on any compiler.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
// ============================================================================ // Author: K Perkins // Date: Oct 27, 2013 // Taken From: http://programmingnotes.org/ // File: ToString.cpp // Description: Demonstrates the use of a custom "ToString" function // which converts a value of a primitive data type (int, double, long, // unsigned, char, etc.) to an std::string. // ============================================================================ #include <iostream> #include <string> #include <sstream> using namespace std; // function prototype template<typename ItemType> string ToString(const ItemType& value); int main() { // declare variables int inum = -1987; double fnum = 7.28; long lnum = 12345678910; char c = 'k'; char cstring[] = "This is a c-string"; string stdString = "This is a std::string"; // convert & save the above values to a std::string buffer string buffer = ToString(inum) + ", " + ToString(fnum) + ", " + ToString(lnum) + ", " + ToString(c) + ", " + ToString(cstring) + ", " + ToString(stdString); cout<<buffer<<endl; return 0; }// end of main /** * FUNCTION: ToString * USE: Converts and returns the parameter "value" to an std::string * @param value - An item of a primitive data type (int, double, long, unsigned, etc.) * @return - An std::string object containing the representation of "value" as * a sequence of characters. */ template<typename ItemType> string ToString(const ItemType& value) { stringstream convert; convert << value; return convert.str(); }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
Once compiled, you should get this as your output
-1987, 7.28, 12345678910, k, This is a c-string, This is a std::string
C++ || Multi Process Server & Client Hash Table Using Thread Pools, Message Queues, & Signal Handlers
The following is another homework assignment which was presented in an Operating Systems Concepts class. Using commandline arguments, the following is a program which implements a multi threaded hash table, utilizing message queues to pass text from a client program to a server program and vice versa. This program makes use of multiple interprocess communication function calls provided on Unix based systems.
REQUIRED KNOWLEDGE FOR THIS PROGRAM
How To Override The Default Signal Handler (CTRL-C)
How To Create And Use Pthreads For Interprocess Communication
How To Use Message Queues For Interprocess Communication
Multi Process Synchronization Producer Consumer Problem Using Pthreads
Sample Input Server Records File - Download Here
==== 1. OVERVIEW ====
Hash tables are widely used for efficient storage and retrieval of data. When using hash tables in multi threaded applications, you must ensure that concurrent accesses into the hash table is free from race conditions, dead locks, and other problems that arise in program synchronization.
One solution to overcome this problem is to prevent concurrent accesses into the hash table altogether; i.e. prior to accessing the hash table, a thread acquires a lock, and then releases the lock after the access is complete. Such approach, although simple, is inefficient. The program demonstrated on this page implements an alternative solution, one which permits safe concurrent accesses into the hash table. In the approach implemented on this page, each hash location within a hash table is protected with a separate lock. Hence, multiple threads access the hash table concurrently as long as they are accessing different hash locations. For greater efficiency, this program also makes use of a thread pool.
==== 2. TECHNICAL DETAILS ====
This program was implemented in two parts; a server program and a client program. The server side of the program maintains a hash table of records and a pool of threads. The client program requests from the server program search records by sending record ids over a message queue. The server program then retrieves a request from the message queue, and wakes up a thread in the thread pool. That awakened thread then uses the id (sent from the client program) to retrieve the corresponding record from the hash table, and sends the found record from the server program to the client program over the message queue.
The server also reads a specified file from the commandline, which stores initial user data that is to be inserted and stored into the hash table. The incoming text file has the following format:
a unique numerical id 1 (an integer)
the first name 1 (a string)
the last name 1 (a string)
.
.
.
a unique numerical id N (an integer)
the first name N (a string)
the last name N (a string)
These three fields make up one single record for one individual. More than one record may be present in the incoming text file.
==== 3. SERVER ====
The server has the following structure and function:
The server program is invoked with the following commandline structure:
./Server [FILE NAME] [NUMBER OF THREADS] (e.g. ./Server database.dat 10)
The server is implemented below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 |
// ============================================================================= // Author: K Perkins // Date: Oct 5, 2013 // Taken From: http://programmingnotes.org/ // File: Server.cpp // Description: Using a Hash Table, this program simulates a server and client // application. The server program maintains a hash table of records and // a pool of threads. The client requests records from the server by sending // record ID's over the message queue. The server retrieves a request from // the message queue and wakes up a thread in the thread pool. The awakened // thread then uses the ID to retrieve the corresponding record from the // hash table and sends the record to the client over the message queue. // // This is the server program which creates a message queue using the msgget() // system call, checks the message queue for new messages using the msgrcv() // system call, and uses the msgsnd system call to send messages back to // the client // ============================================================================= #include <iostream> #include <vector> #include <list> #include <cstdlib> #include <cstring> #include <fstream> #include <csignal> #include <pthread.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #include <unistd.h> using namespace std; // Compile & Run // g++ Server.cpp -o Server -lpthread // ./Server <FILE NAME> <NUMBER OF THREADS> // function prototypes void SignalHandler(int arg); void InsertInitialDataIntoTable(ifstream& infile); void* SearchRecords(void* args); void SendRecord(int id, const char* firstName, const char* lastName); void* GenerateNewRecord(void* args); // items which are placed inside the hash table cell struct Record { int id; char firstName[50]; char lastName[50]; }; // cell for the hash table struct Cell { list<Record> cell; pthread_mutex_t mutex; }; // message queue structure struct MsgQueue { // the channel the connection will be on long messageType; int recordID; char recordName[100]; }; // constant variables const int HASH_TABLE_SIZE = 100; const int NUM_NEW_RECORDS_THREADS = 5; const int CLIENT_TO_SERVER_CHANNEL = 2; const int SERVER_TO_CLIENT_CHANNEL = 4; const int MSG_Q_ID = 0664; // global variables int msqid = 0; // message queue ID vector<Cell> hashTable(HASH_TABLE_SIZE); list<int> recievedMsg; int main(int argc, char* argv[]) { // declare variables srand(time(NULL)); signal(SIGINT, SignalHandler); // override the CTRL-C terminal singal ifstream infile; // used to read in the file int searchThreadNum = 0; // keep track of how many threads are being processed int newRecThreadNum = 0; int numSearchThreads = 0; // how many threads search the table for records key_t key = 0; // generate key to a file pthread_t* searchRecordThreads = NULL; // array of search records threads pthread_t* getNewRecordThreads = NULL; // array of new records threads MsgQueue msg; // instantiate a message queue // check if theres enough commandline args if(argc < 3) { cerr<<"n** ERROR NOT ENOUGH ARGS!nn" <<"USAGE: "<<argv[0]<<" <FILE NAME> <NUMBER OF THREADS>nn"; exit(1); } // open the input records file infile.open(argv[1]); // check to see if file exists if(infile.fail()) { cerr<<"n** ERROR: ""<<argv[1]<<"" could not be found!n"; exit(1); } // insert data into the hash table from the source file InsertInitialDataIntoTable(infile); // close the file after we are done using it infile.close(); // get the number of threads from the command line numSearchThreads = atoi(argv[2]); // initialize the search thread array with the number // specified from the commandline searchRecordThreads = new pthread_t[numSearchThreads]; // initialize the new records thread array with the // specified number getNewRecordThreads = new pthread_t[NUM_NEW_RECORDS_THREADS]; // get a key for our msg queue key = ftok("/bin/ls", 'O'); // check if we got a valid key if(key < 0) { perror("ftok error"); exit(1); } // get a msg ID msqid = msgget(key, MSG_Q_ID | IPC_CREAT); // check if we got a valid ID if(msqid < 0) { perror("msgget error"); exit(1); } cout<<"n** SERVER ID #"<<msqid<<" SUCCESSFULLY ESTABLISHEDn"<<endl; // infinite loop to send/recieve messages to/from client do{ // recieve record from client if(msgrcv(msqid, &msg, sizeof(msg) - sizeof(long), CLIENT_TO_SERVER_CHANNEL, 0) < 0) { perror("msgsnd error"); exit(1); } // save the recieved record from the client into a linked list // this is used in the "SearchRecords" function recievedMsg.push_back(msg.recordID); // --- SEARCH RECORDS THREADS // keep track of how many threads are being used if(searchThreadNum > numSearchThreads-1) { searchThreadNum = 0; } // create threads & send them to work if(pthread_create(&searchRecordThreads[searchThreadNum], NULL, &SearchRecords, NULL) < 0) { perror("pthread_create error"); exit(1); } // wait for threads to finish pthread_join(searchRecordThreads[searchThreadNum], NULL); // --- GENERATE NEW RECORDS THREADS // keep track of how many threads are being used if(newRecThreadNum > NUM_NEW_RECORDS_THREADS-1) { newRecThreadNum = 0; } // create threads & send them to work if(pthread_create(&getNewRecordThreads[newRecThreadNum], NULL, &GenerateNewRecord, NULL) < 0) { perror("pthread_create error"); exit(1); } // wait for threads to finish pthread_join(getNewRecordThreads[newRecThreadNum], NULL); // --- INCREMENT NUMBER OF THREADS BEING USED //cout<<searchThreadNum<<endl; ++searchThreadNum; ++newRecThreadNum; }while(true); return 0; }// end of main void* GenerateNewRecord(void* args) { const char* names[]={"Alva","Edda","Hiram","Lemuel","Della","Roseann","Sang", "Evelia","Claire","Marylou","Magda","Irvin","Reagan","Deb","Hillary", "Tuyetm","Cherilyn","Amina","Justin","Neville","Jessica","Demi", "Graham","Cinderella","Freddy","Vivan","Marjorie","Krystal","Liza", "Spencer","Jordon","Bernie","Geraldine","Kati","Jetta","Carmella", "Chery","Earlene","Gene","Lorri","Albertina","Ula","Karena","Johanna", "Alex","Tobias","Lashawna","Domitila","Chantel","Deneen","Nigel", "Lashanda","Donn","Theda","Many","Jeramy","Jodee","Tamra","Dessie", "Lawrence","Jaime","Basil","Roger","Cythia","Homer","Lilliam","Victoria", "Tod","Harley","Meghann","Jacquelyne","Arie","Rosemarie","Lyndon","Blanch", "Kenneth","Perkins","Kaleena"}; Record temp; int record = rand()%10000; int nameLen = sizeof(names)/sizeof(names[0]); // lock the current hash table cell if(pthread_mutex_lock(&hashTable[record%HASH_TABLE_SIZE].mutex) < 0) { perror("pthread_mutex_lock error"); exit(1); } // put the new data into the hash table temp.id = record; strncpy(temp.firstName, names[rand()%(nameLen-1)], sizeof(temp.firstName)); strncpy(temp.lastName, names[rand()%(nameLen-1)], sizeof(temp.lastName)); hashTable[record%HASH_TABLE_SIZE].cell.push_back(temp); pthread_mutex_init(&hashTable[temp.id%HASH_TABLE_SIZE].mutex, NULL); // unlock the current hash table cell if(pthread_mutex_unlock(&hashTable[record%HASH_TABLE_SIZE].mutex) < 0) { perror("pthread_mutex_lock error"); exit(1); } return 0; }// end of GenerateNewRecord void* SearchRecords(void* args) { int record = 0; bool found = false; // get the record from the client to search the hash table if(!recievedMsg.empty()) { record = recievedMsg.front(); recievedMsg.pop_front(); } //cout<<endl<<record<<endl; // if the current hash table cell isnt empty, search for the record id if(!hashTable[record%HASH_TABLE_SIZE].cell.empty()) { // lock the current hash table cell if(pthread_mutex_lock(&hashTable[record%HASH_TABLE_SIZE].mutex) < 0) { perror("pthread_mutex_lock error"); exit(1); } // search hash table cell to see if given record is there for(list<Record>::iterator iter = hashTable[record%HASH_TABLE_SIZE].cell.begin(); iter != hashTable[record%HASH_TABLE_SIZE].cell.end(); ++iter) { // we found a match in the hash table if(iter->id == record) { // set the data fields of the found record // to prepare it to be sent over the message queue SendRecord(iter->id, iter->firstName, iter->lastName); found = true; break; } } // unlock the current hash table cell if(pthread_mutex_unlock(&hashTable[record%HASH_TABLE_SIZE].mutex) < 0) { perror("pthread_mutex_lock error"); exit(1); } } // if we didnt find a record, tell that to the client if(!found) { SendRecord(-1, "Record Not Found!", ""); } return 0; }// end of SearchRecords void SendRecord(int id, const char* firstName, const char* lastName) { MsgQueue msg; // instantiate a message queue // set the message queue channel msg.messageType = SERVER_TO_CLIENT_CHANNEL; // set the record id msg.recordID = id; // set the record name strncpy(msg.recordName, firstName, sizeof(msg.recordName)); strncat(msg.recordName, " ", sizeof(msg.recordName)); strncat(msg.recordName, lastName, sizeof(msg.recordName)); // send record to client if(msgsnd(msqid, &msg, sizeof(msg) - sizeof(long), 0) < 0) { perror("msgsnd error"); exit(1); } }// end of SendRecord void InsertInitialDataIntoTable(ifstream& infile) { Record temp; while(infile>>temp.id >>temp.firstName >>temp.lastName) { hashTable[temp.id%HASH_TABLE_SIZE].cell.push_back(temp); pthread_mutex_init(&hashTable[temp.id%HASH_TABLE_SIZE].mutex, NULL); } }// end of InsertInitialDataIntoTable void SignalHandler(int arg) { cerr<<"nnCaught the CTRL-Cn" <<"Shutting down the server connection..n"; // deallocate the queue if(msgctl(msqid, IPC_RMID, NULL) < 0) { perror("msgctl error"); } exit(0); }// http://programmingnotes.org/ |
The client program has a much easier flow of control. It is implemented below.
==== 4. CLIENT ====
The client has the following structure and function:
The client program was designed to sleep for 1 second every time a new record is obtained from the server. This makes it so its easier for the user to see what is being displayed on the screen.
The client program is invoked with the following commandline structure:
./client
The client is implemented below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 |
// ============================================================================= // Author: K Perkins // Date: Oct 5, 2013 // Taken From: http://programmingnotes.org/ // File: Client.cpp // Description: Using a Hash Table, this program simulates a server and client // application. The server program maintains a hash table of records and // a pool of threads. The client requests records from the server by sending // record ID's over the message queue. The server retrieves a request from // the message queue and wakes up a thread in the thread pool. The awakened // thread then uses the ID to retrieve the corresponding record from the // hash table and sends the record to the client over the message queue. // // This is the client program which connects to the message queue that the // server previously establishes using the msgget() system call. It checks // the message queue for sucessfully found records using the msgrcv() system // call, and uses the msgsnd system call to send new search records back to // the server, where it searches for new records // // NOTE: This file is set to display records on a 1 second delay // ============================================================================= #include <iostream> #include <cstdlib> #include <ctime> #include <unistd.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> using namespace std; // Compile & Run // g++ Client.cpp -o Client // ./Client // message queue structure struct MsgQueue { // the channel the connection will be on long messageType; int recordID; char recordName[100]; }; // constant variables const int HOW_LONG_TO_SLEEP = 1; const int CLIENT_TO_SERVER_CHANNEL = 2; const int SERVER_TO_CLIENT_CHANNEL = 4; const int MSG_Q_ID = 0664; int main() { // declare variables MsgQueue msg; srand(time(NULL)); key_t key = 0; int msqid = 0; // message queue ID // get a key for the queue key = ftok("/bin/ls", 'O'); // check if we got a valid key if(key < 0) { cerr<<"ftok"; exit(1); } // get the ID of the queue msqid = msgget(key,MSG_Q_ID); // check if we got a valid ID if(msqid < 0) { cerr<<"n** ERROR - CONNECTION TO SERVER NOT FOUNDnn"; exit(1); } cerr<<"n** CONNECTION TO SERVER ID #"<<msqid<<" SUCCESSn"<<endl; // infinite loop to send/recieve messages from server do{ // connect to the server msg.messageType = CLIENT_TO_SERVER_CHANNEL; // generate a random search key msg.recordID = rand()%10000; // send record search to the server if(msgsnd(msqid, &msg, sizeof(msg) - sizeof(long), 0) < 0) { cerr<<"n** SERVER CONNECTION CLOSED..nn"; exit(1); } // recieve a record from the server if(msgrcv(msqid, &msg, sizeof(msg) - sizeof(long), SERVER_TO_CLIENT_CHANNEL, 0) < 0) { cerr<<"n** SERVER CONNECTION CLOSED..nn"; exit(1); } // if we found a valid record, display it to the screen if(msg.recordID > 0) { cerr<< "ID = "<<msg.recordID<<" tRecord = "<<msg.recordName<<endl; sleep(HOW_LONG_TO_SLEEP); } }while(true); return 0; }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
See sample files named server.cpp and client.cpp which illustrate interprocess communications using message queues. See file condvar.cpp which illustrates the use of condition variables. Finally, see file signal.cpp which illustrates the overriding of default signal handlers.
The following is sample output:
(Note: remember to include the initial records input file!)
SERVER OUTPUT:
./Server INPUT_Records_programmingnotes_freeweq_com.txt 26** SERVER ID #1015808 SUCCESSFULLY ESTABLISHED
^C
Caught the CTRL-C
Shutting down the server connection..
CLIENT OUTPUT:
./Client** CONNECTION TO SERVER ID #1015808 SUCCESS
ID = 243 Record = Graham Basil
ID = 7943 Record = Tobias Arie
ID = 3607 Record = Claire Amina
ID = 849 Record = Jetta Victoria
ID = 126 Record = Jeramy Tod
ID = 7483 Record = Vivan Krystal
ID = 8036 Record = Lilliam Harley
ID = 1901 Record = Kati Basil
ID = 3524 Record = Kenneth Perkins
ID = 5256 Record = Jodee Albertina
ID = 7065 Record = Marylou Donn
ID = 3951 Record = Ula Domitila
ID = 395 Record = Jaime Lilliam
ID = 9234 Record = Nigel Gene
ID = 4148 Record = Carmella Evelia
ID = 9340 Record = Sang Cherilyn
ID = 3834 Record = Jessica Freddy** SERVER CONNECTION CLOSED..
C++ || File Copier Using Memory Mapped Files
The following is another homework assignment which was presented in an Operating Systems Concepts class. Using commandline arguments, the following is a program which implements a file copier using memory mapped files. This program makes use of the “mmap” function call provided on Unix based systems.
REQUIRED KNOWLEDGE FOR THIS PROGRAM
How To Use Memory Mapped Files
How To Get The Size Of A File
How To Create A File Of Any Size
==== 1. OVERVIEW ====
A memory mapped file is a segment of virtual memory which has been assigned a direct byte for byte correlation with some portion of a file or file like resource. The primary benefit of memory mapping a file is increasing I/O performance, especially when used on large files. Accessing memory mapped files is faster than using direct read and write operations. Memory mapped files are designed to simplify and optimize file access.
The program demonstrated on this page works with any file type (i.e: txt, cpp, jpg, png, mp4, flv, etc.) and copies the contents of one file, and saves it into another separate output file.
==== 2. TECHNICAL DETAILS ====
This program has the following flow of control:
1. The program is invoked with the source file name and the destination file name as commandline arguments.
2. The program uses the mmap() system call to map both files into memory.
3. The program uses the memory-mapped file memory to to copy the source file to the destination file.
This program is also modified in such a way that you cannot do an mmap on the same file. For example, if you have an input file “A” as the source file, the destination file “B” needs to have a different filename. If both the source and the destination files have the same filename, an error message is displayed, and the program exits. In order for this program to work, the source and the destination files must have different names.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 |
// ============================================================================ // Author: K Perkins // Date: Oct 5, 2013 // Taken From: http://programmingnotes.org/ // File: Mcp.cpp // Description: This program implements a file copier based on memory // mapped files. // This program has the following flow of control: // (1) The program is invoked with the source file name and the // destination file name as parameters. // (2) The program uses the mmap() system call to map both files into // memory. // (3) The program uses the memory-mapped file memory to copy the // source file to the destination file. // ============================================================================ #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring> #include <unistd.h> #include <fcntl.h> #include <sys/stat.h> #include <sys/types.h> #include <sys/mman.h> using namespace std; int main(int argc, char* argv[]) { // declare variables struct stat statInfo; int srcFd = -1; int destFd = -1; int pagesize = -1; int mappingSize = -1; int leftToWrite = -1; off_t offset = 0; char* srcBuff = NULL; char* destBuff = NULL; const char* srcFileName = NULL; const char* destFileName = NULL; FILE* destFp = NULL; // check if theres enough commandline args if(argc < 3) { cerr<<"n** ERROR NOT ENOUGH ARGS!n" <<"nUSAGE: "<<argv[0]<<" <SOURCE FILE NAME> <DESTINATION FILE NAME>nn"; exit(1); } // set the pointers to the source and destination files srcFileName = argv[1]; destFileName = argv[2]; // check if the source and the destination file have the same name if(strncmp(srcFileName, destFileName, sizeof(srcFileName)) == 0) { cerr<<"n** ERROR - The source and destination files both have the " <<"same name..nnPlease select a name other than "" <<srcFileName<<"" for the destination file!nn"; exit(1); } // get the file information if(stat(srcFileName, &statInfo) < 0) { perror("stat error"); exit(1); } // open the destination file destFp = fopen(destFileName, "w+"); // make sure it opened ok if(!destFp) { perror("open error"); exit(1); } // display info to the screen cerr<<"nThe source file ""<<srcFileName<<"" is " <<statInfo.st_size<<" bytesn"; // set the pointer to the end of the file if(fseek(destFp, statInfo.st_size - 1, SEEK_SET) < 0) { perror("fseek error"); exit(1); } // write a single byte to make the destination file // the same size as the "source" file if(fwrite("", 1, sizeof(""), destFp) < 0) { perror("write error"); exit(1); } // close the destination file fclose(destFp); // open the source file for reading srcFd = open(srcFileName, O_RDONLY); // make sure the file was opened successfully if(srcFd < 0) { perror("open error"); exit(1); } // open the destination file again, this time for actual writing destFd = open(destFileName, O_RDWR); // make sure the destination file was opened successfully if(destFd < 0) { perror("open error"); exit(1); } // get the size of the page pagesize = getpagesize(); // how many bytes left to write leftToWrite = statInfo.st_size; // copy the bytes of the source file to the destination file while(leftToWrite) { // if there is more than pagesize bytes, // then map pagesize bytes. Otherwise, // map the remaining bytes if(leftToWrite > pagesize) { mappingSize = pagesize; } else { mappingSize = leftToWrite; } //cerr<<"mappingSize = "<<mappingSize<<endl; // map the pagesized source file if((srcBuff = (char*)mmap(NULL, mappingSize, PROT_READ, MAP_SHARED, srcFd, offset)) == (void*)-1) { perror("mmap1 error"); exit(1); } // map the pagesized destination file if((destBuff = (char*)mmap(NULL, mappingSize, PROT_READ|PROT_WRITE, MAP_SHARED, destFd, offset)) == (void*)-1) { perror("mmap2 error"); exit(1); } // copy the source to destination memcpy(destBuff, srcBuff, mappingSize); // update the number of bytes left to write leftToWrite -= mappingSize; // update the offset offset += mappingSize; // unmap both buffers if(munmap((void*)srcBuff, mappingSize) < 0) { perror("munmap1 error"); exit(1); } if(munmap((void*)destBuff, mappingSize) < 0) { perror("munmap2 error"); exit(1); } } // display info to the screen cerr<<"nThe destination file "" <<destFileName<<"" has been created and is "<<offset<<" bytesnn"; // close both file descriptors close(srcFd); close(destFd); return 0; }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
The following is sample output:
./mcp 1.png 2.pngThe source file "1.png" is 42004 bytes
The destination file "2.png" has been created and is 42004 bytes
C++ || Snippet – How To Create A File Of Any Size
The following is sample code which demonstrates how to create a file of any size using the fseek and fwrite function calls.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
// ============================================================================ // Author: K Perkins // Date: Oct 4, 2013 // Taken From: http://programmingnotes.org/ // File: createfileN.cpp // Description: Demonstrate how to create a file of any size // ============================================================================ #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring> using namespace std; int main(int argc, char* argv[]) { // declare variables int fileSize = 0; FILE* fp = NULL; // check the command line arguments if(argc < 3) { cerr<<"n** ERROR NOT ENOUGH ARGS!n" <<"nUSAGE: "<<argv[0]<<" <FILE NAME> <FILE SIZE>nn"; exit(1); } // convert the file size from string to integer fileSize = atoi(argv[2]); // open the file to be created fp = fopen(argv[1], "w+"); // make sure the file was created ok if(!fp) { perror("open error"); exit(1); } // set the file marker to position N in the file (where N = file size) if(fseek(fp, fileSize - 1, SEEK_SET) < 0) { perror("fseek error"); exit(1); } // write a single byte to the file if(fwrite(" ", sizeof(char), strlen(" "), fp) < 0) { perror("write error"); exit(1); } // close the file fclose(fp); return 0; }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
The following is sample output:
./createfileN createfile.txt 12[FILE "createfile.txt" IS CREATED AND IS 12 BYTES IN SIZE]
C++ || Snippet – How To Use Memory Mapped Files
The following is sample code which demonstrates the use of the “mmap”, “munmap” and “getpagesize” function calls on Unix based systems.
A memory mapped file is a segment of virtual memory which has been assigned a direct byte for byte correlation with some portion of a file or file like resource. This resource is typically a file that is physically present on disk, but can also be a device, shared memory object, or other resource that the operating system can reference through a file descriptor.
The primary benefit of memory mapping a file is increasing I/O performance, especially when used on large files. Accessing memory mapped files is faster than using direct read and write operations for two reasons. Firstly, a system call is orders of magnitude slower than a simple change to a program’s local memory. Secondly, in most operating systems the memory region mapped actually is the kernel’s page cache (file cache), meaning that no copies need to be created in user space.
The following example demonstrates the use of the “mmap” to map a file into memory, and display its contents to the screen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
// ============================================================================ // Author: K Perkins // Date: Oct 4, 2013 // Taken From: http://programmingnotes.org/ // File: mmap.cpp // Description: Demonstrate the use of memory mapped files // ============================================================================ #include <iostream> #include <cstdlib> #include <unistd.h> #include <sys/mman.h> #include <fcntl.h> using namespace std; int main(int argc, char* argv[]) { // declare variables int fd = -1; int pagesize = -1; char* data = NULL; // check if theres enough commandline args if(argc < 2) { cerr<<"USAGE: "<<argv[0]<<" <FILE NAME>n"; exit(1); } // open the specified file fd = open(argv[1], O_RDWR); // check if the open was successful if(fd < 0) { cerr<<"open error (file not found)n"; exit(1); } // get the page size pagesize = getpagesize(); // map the file into memory data = (char*)mmap((caddr_t)0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); // did the mapping succeed ? if(!data) { cerr<<"mmap errorn"; exit(1); } // print the whole file character-by-character for(int x = 0; x < pagesize; ++x) { cerr<<data[x]; } // optional: write a string to the file //memcpy(data, "Hello world, this is a testn", sizeof("Hello world, this is a test")); // unmap the shared memory region munmap(data, pagesize); // close the file close(fd); return 0; }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
The following is sample output:
./mmap mmap.cpp[THE CONTENTS OF "MMAP.CPP" IS DISPLAYED TO THE SCREEN]
C++ || Snippet – How To Display The Size Of A File Using Stat
The following is sample code which demonstrates the use of the “stat” function calls on Unix based systems.
The stat function returns information about a file. No permissions are required on the file itself, but-in the case of stat() and lstat() – execute (search) permission is required on all of the directories in path that lead to the file.
The “stat” system call returns a stat structure, which contains the following fields:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
struct stat { dev_t st_dev; /* ID of device containing file */ ino_t st_ino; /* inode number */ mode_t st_mode; /* protection */ nlink_t st_nlink; /* number of hard links */ uid_t st_uid; /* user ID of owner */ gid_t st_gid; /* group ID of owner */ dev_t st_rdev; /* device ID (if special file) */ off_t st_size; /* total size, in bytes */ blksize_t st_blksize; /* blocksize for file system I/O */ blkcnt_t st_blocks; /* number of 512B blocks allocated */ time_t st_atime; /* time of last access */ time_t st_mtime; /* time of last modification */ time_t st_ctime; /* time of last status change */ }; |
The following example demonstrates the use of the “st_size” struct parameter to display the size of a file.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
// ============================================================================ // Author: K Perkins // Date: Oct 4, 2013 // Taken From: http://programmingnotes.org/ // File: Stat.cpp // Description: Demonstrate the use of the "stat" function to display the // size of a file // ============================================================================ #include <iostream> #include <cstdlib> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> using namespace std; int main(int argc, char* argv[]) { // declare variables struct stat fileInfo; // the buffer to store file information // check to see if theres enough commandline args if(argc < 2) { cerr<<"n** ERROR - NOT ENOUGH ARGUMENTS!n" <<"nUSAGE: "<<argv[0]<<" <FILE NAME>n"; exit(1); } // get the file information if(stat(argv[1], &fileInfo) < 0) { cerr<<"nstat failed (file not found)n"; exit(1); } // display info to the screen cerr<<"nThe file ""<<argv[1]<<"" is "<<(int)fileInfo.st_size<<" bytesnn"; return 0; }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
The following is sample output:
./Stat Stat.cppThe file "Stat.cpp" is 1170 bytes
C++ || Snippet – How To Use Message Queues For Interprocess Communication
The following is sample code which demonstrates the use of the msgsnd, msgrcv, and msgget function calls for use with message queues on Unix based systems.
Message queues are used for interprocess communication. They provide two (or more) separate programs (i.e: sender and receiver) with the ability to interact with eachother. This is ideal because the sender and receiver do not need to interact with the message queue at the same time. Messages can be sent at one point in time, be placed on the queue until the receiver is ready for it, and then be removed at another point in time when the program(s) that service the queue are finally ready to receive a message.
This concept is different from threaded and forked process IPC procedures, which often times process data in a more streamlined manner. Rather than following a strict pattern as to when data is to be sent and received, queuing is a mechanism in which messages are held until the receiving application is ready to process them.
The example on this page demonstrates the above use of a message queue to transfer data between two separate programs. The sending program (client.cpp) sends an integer and string variable to the receiving program (server.cpp), which then displays that received data to the screen.
NOTE: The server program must be ran before the client program!
=== 1. Server.cpp (Receiver) ===
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 |
// ============================================================================ // Author: Kenneth Perkins // Date: Oct 4, 2013 // Taken From: http://programmingnotes.org/ // File: Server.cpp // Description: Demonstrate the use of a message queue for interprocess // communication. This program illustrates the server (receiving) end of // the message queue. // ============================================================================ #include <iostream> #include <cstdlib> #include <unistd.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> using namespace std; // Compile & Run // g++ Server.cpp -o Server // ./Server // the structure representing the message queue // & must match the same layout as in the client.cpp struct MsgQueue { // IMPORTANT: every message structure must start with this long messageType; // these variables are optional & you can add // more or less if you wish int someNumber; char buff[100]; }; // message queue flag const int MSG_Q_KEY_FLAG = 0664; // message queue data transfer channel const int MSG_Q_CHANNEL = 26; int main() { // declare variables key_t key = -1; int msqid = -1; MsgQueue msg; // use a random file and a random character to generate // a unique key. The same parameters to this function will // always generate the same value. This is how multiple // processes can connect to the same queue. key = ftok("/bin/ls", 'K'); // was the key allocation successful ? if(key < 0) { perror("ftok error"); exit(1); } // allocate the message queue if it does not already exist. // this function returns the id of the queue. msqid = msgget(key, MSG_Q_KEY_FLAG | IPC_CREAT); // was the allocation a success ? if(msqid < 0) { perror("msgget"); exit(1); } // display info to the screen cout <<"\nThe server has started!\n" <<"\nWaiting for someone to connect to server id #"<<msqid<<" with " <<"the key "<<key<<endl<<endl; // recieve 10 messages from the client for(int x = 0; x < 10; ++x) { // this is where we receive messages: // @param: msqid - the id of the message queue // @param: msg - the message structure which stores the // received message // @param: sizeof(msg) - sizeof(long) - size of the message // excluding the required first member (messageType) which is // required. // @param: MSG_Q_CHANNEL - receive all messages whose type parameter // is set equal to "MSG_Q_CHANNEL" // @param: 0 - flag values (not useful for this example). if(msgrcv(msqid, &msg, sizeof(msg) - sizeof(long), MSG_Q_CHANNEL, 0) < 0) { perror("msgrcv"); exit(1); } // print the received message from the client cout << "someNumber = "<<msg.someNumber<<" buff = "<<msg.buff<<endl; } // finally, deallocate the message queue if(msgctl(msqid, IPC_RMID, NULL) < 0) { perror("msgctl"); exit(1); } cout << "\nServer is now shutting down!\n"; return 0; }// http://programmingnotes.org/ |
=== 2. Client.cpp (Sender) ===
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
// ============================================================================ // Author: Kenneth Perkins // Date: Oct 4, 2013 // Taken From: http://programmingnotes.org/ // File: Client.cpp // Description: Demonstrate the use of a message queue for interprocess // communication. This program illustrates the client (sending) end of // the message queue // ============================================================================ #include <iostream> #include <cstdlib> #include <cstring> #include <unistd.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> using namespace std; // Compile & Run // g++ Client.cpp -o Client // ./Client // the structure representing the message queue // & must match the same layout as in the server.cpp struct MsgQueue { // IMPORTANT: every message structure must start with this long messageType; // these variables are optional & you can add // more or less if you wish int someNumber; char buff[100]; }; // message queue flag const int MSG_Q_KEY_FLAG = 0664; // message queue type const int MSG_Q_CHANNEL = 26; int main() { // declare variables key_t key = -1; int msqid = -1; MsgQueue msg; // use a random file and a random character to generate // a unique key. The same parameters to this function will // always generate the same value. This is how multiple // processes can connect to the same queue. key = ftok("/bin/ls", 'K'); // was the key allocation successful ? if(key < 0) { perror("ftok"); exit(1); } // connect to the message queue; fail if the // there is no message queue associated with // this key. This function returns the id of // the queue. msqid = msgget(key, MSG_Q_KEY_FLAG); // was the allocation a success ? if(msqid < 0) { perror("msgget"); exit(1); } // display info to the screen cout <<"\nSuccessfully connected to server id #"<<msqid<<" with " <<"the key "<<key <<"\n\nNow sending messages...."; // send 10 messages to the server for(int x = 0; x < 10; ++x) { // set the message type - this must match // the 4th parameter of msgrcv() in the server.cpp code msg.messageType = MSG_Q_CHANNEL; // place data into the message queue structure to send to the server msg.someNumber = x; strncpy(msg.buff, "Message queues are awesome!", sizeof(msg.buff)); // this is where we send messages: // @param: msqid - the id of the message queue // @param: msg - the message structure which stores the // message to send // @param: sizeof(msg) - sizeof(long) - size of the message // excluding the required first member (messageType) which is // required. // @param: 0 - flag values (not useful for this example). if(msgsnd(msqid, &msg, sizeof(msg) - sizeof(long), 0) < 0) { perror("msgsnd"); exit(1); } } cout << "Sending complete!\n"; return 0; }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
You can view all allocated message queues using the ipcs command. You can delete a message queue from command line using ipcrm -q [KEY SHOWN BY IPCS]. Message queues are a finite resource. If something goes wrong during the execution of your program, you must manually delete all your queues.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
The following is sample output.
SERVER OUTPUT:
The server has started!Waiting for someone to connect to server id #753664 with the key 1258295474
someNumber = 0 buff = Message queues are awesome!
someNumber = 1 buff = Message queues are awesome!
someNumber = 2 buff = Message queues are awesome!
someNumber = 3 buff = Message queues are awesome!
someNumber = 4 buff = Message queues are awesome!
someNumber = 5 buff = Message queues are awesome!
someNumber = 6 buff = Message queues are awesome!
someNumber = 7 buff = Message queues are awesome!
someNumber = 8 buff = Message queues are awesome!
someNumber = 9 buff = Message queues are awesome!Server is now shutting down!
CLIENT OUTPUT:
Successfully connected to server id #753664 with the key 1258295474Now sending messages....Sending complete!
C++ || Snippet – Multi-Process Synchronization Producer Consumer Problem Using Threads
The following is sample code which demonstrates the use of POSIX threads (pthreads), aswell as pthread mutex and condition variables for use on Unix based systems.
The use of mutual exclusion (mutex) variables refers to the requirement of ensuring that no two processes or threads are in their critical section at the same time. Here, a critical section refers to the period of time in which a process accesses a shared resource, such as shared memory. This procedure highlights a classic example of a multi-process synchronization problem known as the producer–consumer problem.
The producer–consumer problem describes a scenario in which two processes (the producer and the consumer) share a common resource (i.e: a string buffer). In this scenario, the producer’s job is to generate a piece of data, update that data with the shared resource (the buffer), and repeat. At the same time, the consumer is consuming that shared resource (i.e: removing something from that same buffer) one piece at a time. The problem is to make sure that the producer wont try to manipulate that shared resource (i.e: add data into the buffer) while the consumer is accessing it; and that the consumer wont try to remove data from that shared resource (the buffer) while the producer is updating it.
In this instance, a solution for the producer can be to go to sleep if a synchronization conflict occurs, and the next time the consumer removes an item from the buffer, it can notify the producer to wake up and start to fill the buffer again. In the same way, the consumer can go to sleep when the producer is accessing it. The next time the producer puts data into the buffer, it wakes up the sleeping consumer and the process continues.
The example on this page demonstrates the use of the above solution using the “pthread_mutex_lock()” function call to limit access to the critical section, and the “pthread_cond_wait()” function call to simulate the sleeping process.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 |
// ============================================================================ // Author: Kenneth Perkins // Date: Oct 3, 2013 // Taken From: http://programmingnotes.org/ // File: Condvar.cpp // Description: Demonstrate the use of the producer consumer problem // using mutex and condition variables // ============================================================================ #include <iostream> #include <cstdlib> #include <pthread.h> using namespace std; // Compile & Run // g++ Condvar.cpp -lpthread -o Condvar // ./Condvar // function prototypes void* Produce(void* arg); void* Consume(void* arg); // global variables // the mutex and the condition variable pthread_mutex_t mutex; pthread_cond_t cond; // the condition flag bool condition = false; // the item produced int count = 0; // how much to produce const int NUM_TO_PRODUCE = 6; int main() { // declare variables pthread_t producerThread; pthread_t consumerThread; // initialize the mutex and the condition variable pthread_mutex_init(&mutex, NULL); pthread_cond_init(&cond, NULL); cout <<"\nThe Parent is creating the producer and consumer threads..\n" << endl; // create a producer thread if(pthread_create(&producerThread, NULL, Produce, NULL) < 0) { perror("pthread_create"); exit(1); } // create a consumer thread if(pthread_create(&consumerThread, NULL, Consume, NULL) < 0) { perror("pthread_create"); exit(1); } // wait for the threads to complete // similar to the wait() system call for fork() processes if(pthread_join(producerThread, NULL) < 0) { perror("pthread_join"); exit(1); } if(pthread_join(consumerThread, NULL) < 0) { perror("pthread_join"); exit(1); } cout <<"\nBoth threads have completed and have terminated!\n" <<"\nThe Parent is now exiting...\n"; return 0; }// end of main /** * The producer thread function * @param arg - pointer to the thread local data - unused */ void* Produce(void* arg) { // produce things until the loop condition is met while(count < NUM_TO_PRODUCE) { // lock the mutex to protect the condition variable if(pthread_mutex_lock(&mutex) < 0) { perror("pthread_mutex_lock"); exit(1); } // we have produced something that has not been // consumed yet, so we sleep (wait) until the consumer // wakes us up. while(condition) { // sleep (wait) on a condition variable until the // the consumer wakes the producer up. if(pthread_cond_wait(&cond, &mutex) < 0) { perror("pthread_cond_wait"); exit(1); } } // produce an item cout <<"Produced: "<<++count<<endl; // we have produced something condition = true; // wake up the sleeping consumer if(pthread_cond_signal(&cond) < 0) { perror("pthread_cond_signal"); exit(1); } // release the mutex lock if(pthread_mutex_unlock(&mutex) < 0) { perror("pthread_mutex_unlock"); exit(1); } } return 0; }// end of Produce /** * The consumer function * @param arg - pointer to the thread local data - unused */ void* Consume(void* arg) { // consume things until the loop condition is met while(count < NUM_TO_PRODUCE) { // lock the mutex to protect the condition variable if(pthread_mutex_lock(&mutex) < 0) { perror("pthread_mutex_lock"); exit(1); } // if there is nothing to consume, then sleep while(!condition) { // sleep (wait) on a condition variable until the // producer wakes the consumer up. if(pthread_cond_wait(&cond, &mutex) < 0) { perror("pthread_cond_wait"); exit(1); } } cout <<"Consumed: "<<count<<endl<<endl; // consume the item condition = false; // wake up the sleeping producer if(pthread_cond_signal(&cond) < 0) { perror("pthread_cond_signal"); exit(1); } // unlock the mutex if(pthread_mutex_unlock(&mutex) < 0) { perror("pthread_mutex_unlock"); exit(1); } } return 0; }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
To use pthreads, the compiler flag “-lpthread” must be set.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
The following is sample output:
The Parent is creating the producer and consumer threads..Produced: 1
Consumed: 1Produced: 2
Consumed: 2Produced: 3
Consumed: 3Produced: 4
Consumed: 4Produced: 5
Consumed: 5Produced: 6
Consumed: 6Both threads have completed and have terminated!
The Parent is now exiting...
C++ || Snippet – How To Create And Use Threads For Interprocess Communication
The following is sample code which demonstrates the use of POSIX threads (pthreads), aswell as the pthread_create, and pthread_join function calls on Unix based systems.
Much like the fork() function call which is used to create new processes, threads are similar in that they too are used for interprocess communication. Threads allow for multi-threading, which is a widespread programming and execution model that allows for multiple threads to exist within the same context of a single program.
Threads share the calling parent process’ resources. Each process has it’s own address space, but the threads within the same process share that address space. Threads also share any other resources within that process. This means that it’s very easy to share data amongst threads, but it’s also easy for the threads to step on each other, which can lead to bad things.
The example on this page demonstrates the use of multiple pthreads to display shared data (an integer variable) to the screen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
// ============================================================================ // Author: Kenneth Perkins // Date: Oct 3, 2013 // Taken From: http://programmingnotes.org/ // File: Pthread.cpp // Description: Demonstrate the use of using multiple threads using the // pthread_create() function // ============================================================================ #include <iostream> #include <cstdlib> #include <pthread.h> using namespace std; // Compile & Run // g++ Pthread.cpp -lpthread -o Pthread // ./Pthread <NUMBER OF THREADS TO CREATE> // function prototype void* ThreadFunc(void* args); // global variable int threadNum = 0; int main(int argc, char* argv[]) { // declare variables int numberOfThreads = 0; pthread_t* threads; // make sure theres enough commandline arguments // and EXIT if theres not if(argc < 2) { cout <<"** ERROR - NOT ENOUGH ARGS!\n" <<"\nUSAGE:"<<argv[0]<<" <NUMBER OF THREADS TO CREATE>\n"; exit(1); } // convert the number of threads from the command line // from string to int value numberOfThreads = atoi(argv[1]); // declare the array of thread variables threads = new pthread_t[numberOfThreads]; cout <<"\nThe Parent is creating "<<numberOfThreads<<" threads!" << endl; // use a loop to create the threads for(int x = 0; x < numberOfThreads; ++x) { // create the thread and call the "ThreadFunc" if(pthread_create(&threads[x], NULL, ThreadFunc, NULL) < 0) { perror("pthread_create error"); exit(1); } } cout <<"The Parent is now waiting for the thread(s) to complete...\n\n"; // wait for all threads to finish for(int x = 0; x < numberOfThreads; ++x) { pthread_join(threads[x], NULL); } cout <<"\nAll thread(s) are complete and have terminated!\n" <<"\nThe Parent is now exiting...\n"; return 0; }// end of main /** * The function called by the thread * @param args - pointer to the thread local data */ void* ThreadFunc(void* args) { // display the thread info cout <<"Hi, Im thread #"<<++threadNum <<" and this is my id number: "<<(unsigned)pthread_self()<<endl; return 0; }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
So, what is the difference between fork() processes and thread processes? Threads differ from traditional multitasking operating system processes in that:
• processes are typically independent, while threads exist as subsets of a process
• processes carry considerable state information, whereas multiple threads within a process share state as well as memory and other resources
• processes have separate address spaces, whereas threads share their address space
• processes interact only through system-provided inter-process communication mechanisms.
• Context switching between threads in the same process is typically faster than context switching between processes.
To use pthreads, the compiler flag “-lpthread” must be set.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
The following is sample output:
./Pthread 5The Parent is creating 5 threads!
The Parent is now waiting for the thread(s) to complete...Hi, Im thread #1 and this is my id number: 1664468736
Hi, Im thread #2 and this is my id number: 1647683328
Hi, Im thread #3 and this is my id number: 1656076032
Hi, Im thread #4 and this is my id number: 1672861440
Hi, Im thread #5 and this is my id number: 1681254144All thread(s) are complete and have terminated!
The Parent is now exiting...
C++ || Snippet – How To Override The Default Signal Handler (CTRL-C)
The following is sample code which demonstrates the use of the “signal” function call on Unix based systems.
Signals are interrupts delivered to a process by the operating system which can terminate a program prematurely. You can generate interrupts by pressing Ctrl+C. The “signal” function call receives two arguments. The first argument is an integer which represents the signal number, and the second argument is a pointer to the user defined signal handling function.
The following program catches the “SIGINT” signal number using the signal() function.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
// ============================================================================ // Author: K Perkins // Date: Oct 3, 2013 // Taken From: http://programmingnotes.org/ // File: Signal.cpp // Description: Demonstrate the use of overriding the default signal // handler for the case when the user presses Ctrl-C. Test it by // running and pressing Ctrl-C // ============================================================================ #include <iostream> #include <csignal> #include <unistd.h> using namespace std; // function prototype void SignalHandlerFunc(int arg); // global variable int count = 10; int main() { // overide the default signal handler (CTRL-C) // with our own "SignalHandlerFunc" function signal(SIGINT, SignalHandlerFunc); cerr<<"nPlease press CTRL-Cnn"; // loop until condition is met do{ sleep(1); }while(count > 0); // press ENTER on the keyboard to end // the program once all "lives" are lost cin.get(); return 0; }// end of main /** * This function handles the signal * @param arg - the signal number */ void SignalHandlerFunc(int arg) { // display text when user presses CTRL-C if(count > 0) { cerr<<" Haha I have "<<count<<" lives!n"; } else { cerr<<" ** Ahh you got me...n"; } --count; }// http://programmingnotes.org/ |
QUICK NOTES:
The highlighted lines are sections of interest to look out for.
The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.
The following is sample output:
Please press CTRL-C^C Haha I have 10 lives!
^C Haha I have 9 lives!
^C Haha I have 8 lives!
^C Haha I have 7 lives!
^C Haha I have 6 lives!
^C Haha I have 5 lives!
^C Haha I have 4 lives!
^C Haha I have 3 lives!
^C Haha I have 2 lives!
^C Haha I have 1 lives!
^C ** Ahh you got me...
Hi, I'm a software engineer. I write articles about programming and design in my spare time.
