ada/csce313-mp4pinie64backup
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

s

Browse source
This commit is contained in:
Eric Buxkemper 2015-11-13 10:04:10 -06:00
commit 7f0b06ef71
1 changed files with 0 additions and 295 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

295
simpleclient.cpp
View file

@ -1,295 +0,0 @@
/*
File: simpleclient.C
Author: R. Bettati
Department of Computer Science
Texas A&M University
Date : 2013/01/31
Simple client main program for MP3 in CSCE 313
*/
/*--------------------------------------------------------------------------*/
/* DEFINES */
/*--------------------------------------------------------------------------*/
/* -- (none) -- */
/*--------------------------------------------------------------------------*/
/* INCLUDES */
/*--------------------------------------------------------------------------*/
#include <cassert>
#include <cstring>
#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include "reqchannel.h"
#include "semaphore.h"
#include "BoundedBuffer.h"
using namespace std;
/*--------------------------------------------------------------------------*/
/* DATA STRUCTURES */
/*--------------------------------------------------------------------------*/
/* none */
/*--------------------------------------------------------------------------*/
/* CONSTANTS */
/*--------------------------------------------------------------------------*/
BoundedBuffer Request_Buffer;
BoundedBuffer Response_Buffer[3];
BoundedBuffer RB1;
vector<int> John_vec(100);
vector<int> Jane_vec(100);
vector<int> Joe_vec(100);
int n = 1000, b = 100, w = 5;//set defaults
/*--------------------------------------------------------------------------*/
/* FORWARDS */
/*--------------------------------------------------------------------------*/
void* Req_Thread(void* args);
void* Worker_Thread(void* args);
void* Stat_Thread(void* args);
/*--------------------------------------------------------------------------*/
/* MAIN FUNCTION */
/*--------------------------------------------------------------------------*/
int main(int argc, char * argv[]) {
int option = -1;
while ((option = getopt(argc, argv, "n:b:w:")) != -1){
switch (option){
case 'n' :
n = atoi(optarg);
break;
case 'b' :
b = atoi(optarg);
break;
case 'w' :
w = atoi(optarg);
break;
}
}
pid_t pid = fork();
if(pid != 0){
Request_Buffer.set_empty(b);
Response_Buffer[0].set_empty(b);
Response_Buffer[1].set_empty(b);
Response_Buffer[2].set_empty(b);
RequestChannel chan("control", RequestChannel::CLIENT_SIDE);
<<<<<<< HEAD
pthread_t request_thread_ids[3];
pthread_t worker_thread_ids[w];
pthread_t statistic_thread_ids[3];
RequestChannel* worker_return[w];
=======
cout << "done." << endl;
for(int i = 0; i < 3; i++){
pid = fork();
if(pid){ //if in the parent still
if(i == 0){
Req_Thread(" Joe Smith");
}else if(i == 1){
Req_Thread(" Jane Smith");
}else if(i == 2){
Req_Thread(" John Doe");
}
continue;
}else if (pid == 0){
break;
} else {
exit(1);
}
}
<<<<<<< HEAD
string channel_name;
for(int i=0; i < w; i++){
channel_name = chan.send_request("newthread");
cout << "\nChan: " << channel_name << endl;
RequestChannel* worker_ret = new RequestChannel(channel_name, RequestChannel::CLIENT_SIDE);
pid = fork();
if(pid != 0) {
Worker_Thread(argv, worker_ret);
break;
}
}
chan.send_request("quit");
=======
>>>>>>> 4a988cc17197484a727d1eafa31fc5dc8788b952
//---------------------------------------------
//------- pthread_create -------
//---------------------------------------------
int index[3];
for(int i=0; i < 3; i++){
index[i] = i;
pthread_create(&request_thread_ids[i], NULL, Req_Thread, (void *)&index[i]);
}
for(int i=0; i < w; i++){
string channel_name = chan.send_request("newthread");
worker_return[i] = new RequestChannel(channel_name, RequestChannel::CLIENT_SIDE);
pthread_create(&worker_thread_ids[i], NULL, Worker_Thread, worker_return[i]);
}
for(int i=0; i < 3; i++){
pthread_create(&statistic_thread_ids[i], NULL, Stat_Thread, (void *)&i);
}
//---------------------------------------------
//-------- pthread_join --------
//---------------------------------------------
for(int i=0; i < 3; i++){
pthread_join(request_thread_ids[i], NULL);
}
for(int i=0; i < w; i++){
pthread_join(worker_thread_ids[i], NULL);
}
for(int i=0; i < 3; i++){
pthread_join(statistic_thread_ids[i], NULL);
}
for(int i=0; i < w; i++){
worker_return[i]->send_request("quit");
}
cout << "\n\n HISTOGRAM \n";
int ct = 0;
for(int i=0; i < 100; i++){
cout << "Num: " << i << "\tTimes: " << John_vec[i] << endl;
}
//STILL NEED TO OUTPUT THE HISTOGRAM SOMEHOW....
chan.send_request("quit");
}else{
<<<<<<< HEAD
execl("dataserver", 0);
=======
execve("dataserver", argv, argv);
>>>>>>> 7f3859db688a7e8629c7a88e7baad87ad6df405d
>>>>>>> 4a988cc17197484a727d1eafa31fc5dc8788b952
}
usleep(1000000);
}
<<<<<<< HEAD
void* Worker_Thread(void* arg){
RequestChannel* chann = (RequestChannel*)arg;
while(true){
string request = Request_Buffer.pop();
string response = chann->send_request(request);
if(request == "data Joe Smith"){
Response_Buffer[0].push(response);
}else if(request == "data Jane Smith"){
Response_Buffer[1].push(response);
}else if(request == "data John Doe"){
Response_Buffer[2].push(response);
}else if(request == "quit"){ //Break out of the thread if quit response is found
break;
}
=======
void* Worker_Thread(char* arg[], RequestChannel* chan){
<<<<<<< HEAD
//handles the data moving between the Server and Bounded Buffer
//control chan("control", RequestChannel::CLIENT_SIDE);
//string channel_name = control.send_request("newthread");
//RequestChannel * channel_ret = new RequestChannel(channel_name, RequestChannel::CLIENT_SIDE);
while(true){
=======
while(true){
>>>>>>> 7f3859db688a7e8629c7a88e7baad87ad6df405d
string req = Request_Buffer->pop();
cout << "Request: " << req << endl;
string response = chan->send_request(req);
cout << "Response: " << response << endl;
//local_send_request(req, response);
>>>>>>> 4a988cc17197484a727d1eafa31fc5dc8788b952
}
}
void* Req_Thread(void* arg){
int person = *(int*)arg;
cout << "PERSON: " << person << endl;
switch(person){
case 0:
for(int i=0; i < n; i++){ Request_Buffer.push("data Joe Smith"); cout << "JOE";}
break;
case 1:
for(int i=0; i < n; i++){ Request_Buffer.push("data Jane Smith"); cout << "JANE";}
break;
case 2:
for(int i=0; i < n; i++){ Request_Buffer.push("data John Doe"); cout << "JOHN";}
break;
}
}
void* Stat_Thread(void* arg){
//send to proper response buffer based on which name is found!
int person = *(int*)arg;
string num;
if(person == 0){
for(int i=0; i < n; i++){
num = Response_Buffer[0].pop();
int v = atoi(num.c_str());
John_vec[v] = John_vec[v] + 1;
}
}else if(person == 1){
for(int i=0; i < n; i++){
num = Response_Buffer[1].pop();
cout << "\nPERSON1: " << num << endl;
int v = atoi(num.c_str());
Jane_vec[v] = Jane_vec[v] + 1;
}
}else if(person == 2){
for(int i=0; i < n; i++){
num = Response_Buffer[2].pop();
int v = atoi(num.c_str());
John_vec[v] = John_vec[v] + 1;
}
}
}