int main(int argc, char *argv[]){
// Call handle shutdown if "Ctrl+C" is hit
if (catch_signal(SIGINT, handle_shutdown) == -1)
error("Can’t set the interrupt handler");
listener_d = open_listener_socket();
// Create a socket
bind_to_port(listener_d, 30000);
// Set the listen queue lenght to 10
if (listen(listener_d, 10) == -1)
error("Can’t listen");
struct sockaddr_storage client_addr;
unsigned int address_size = sizeof(client_addr);
puts("Waiting for connection");
char buf[255];
while (1) {
// Listen for a connection
int connect_d = accept(listener_d, (struct sockaddr *)&client_addr, &address_size);
if (connect_d == -1)
error("Can’t open secondary socket");
if(!fork()){
close(listen_d);
// Send data to the client
if (say(connect_d, "Internet Knock-Knock Protocol Server\r\nVersion 1.0\r\nKnock! Knock!\r\n>") != -1) {
read_in(connect_d, buf, sizeof(buf));
// Check the clients answers
if (strncasecmp("Who's there?", buf, 12))
say(connect_d, "You should say 'Who's there?'!");
else {
if (say(connect_d, "Oscar\r\n> ") != -1) {
read_in(connect_d, buf, sizeof(buf));
if (strncasecmp("Oscar who?", buf, 10))
say(connect_d, "You should say 'Oscar who?'!\r\n");
else
say(connect_d, "Oscar silly question, you get a silly answer\r\n");
}
}
}
close(connect_d);
exit(0);
}
// close secondary socket.
close(connect_d);
}
return 0;
}
int parse_path (struct connection *c) {
int sz;
if (read_in (c->Tmp, &sz, sizeof (sz)) != sizeof (sz)) {
return -1;
}
if (read_in (c->Tmp, value_buff, sz) != sz) {
return -2;
}
value_buff[sz] = 0;
return 0;
}
int main(int argc, char *argv[])
{
int connect_d = 0, rc = 0;
char intro_msg[] = "Internet Knock-Knock Protocol Server\nKnock, knock.\n";
if (catch_signal(SIGINT, handle_shutdown) == -1)
error("Setting interrupt handler");
int port = 30000;
listener_d = open_listener_socket();
bind_to_port(listener_d, port);
if (listen(listener_d, 10) == -1)
error("Can't listen");
printf("Waiting for connection on port %d\n", port);
char buf[255];
while (1) {
connect_d = open_client_socket();
if (say(connect_d, intro_msg) == -1) {
close(connect_d);
continue;
}
read_in(connect_d, buf, sizeof(buf));
// check to make sure they said "Who's there?"
if (say(connect_d, "Surrealist giraffe.\n") == -1) {
close(connect_d);
continue;
}
read_in(connect_d, buf, sizeof(buf));
// check to make sure they said "Surrealist giraffe who?"
if (say(connect_d, "Bathtub full of brightly-colored machine tools.\n") == -1) {
close(connect_d);
continue;
}
close(connect_d);
}
return 0;
}
TEST(Parser, ParseMpzClass)
{
std::stringstream read_in("-12412312");
mpz_class val;
EXPECT_TRUE(parse_mpz_class(read_in, val));
EXPECT_EQ(-12412312_mpz, val);
}
static int rpcc_process_handshake_packet (struct connection *c) {
struct rpcc_data *D = RPCC_DATA(c);
static struct rpc_handshake_packet P;
if (D->packet_num != -1 || D->packet_type != RPC_HANDSHAKE) {
return -2;
}
if (D->packet_len != sizeof (struct rpc_handshake_packet)) {
rpcc_send_handshake_error_packet (c, -3);
return -3;
}
assert (read_in (&c->In, &P, D->packet_len) == D->packet_len);
if (!matches_pid (&P.sender_pid, &D->remote_pid)) {
rpcc_send_handshake_error_packet (c, -6);
return -6;
}
if (!P.sender_pid.ip) {
P.sender_pid.ip = D->remote_pid.ip;
}
memcpy (&D->remote_pid, &P.sender_pid, sizeof (struct process_id));
if (!matches_pid (&PID, &P.peer_pid)) {
rpcc_send_handshake_error_packet (c, -4);
return -4;
}
return 0;
}
int
main(int argc, char **argv)
{
size_t i;
if(argc != 1) {
usage(stderr);
return 0;
}
/* read in */
ldns_rr_list *list = ldns_rr_list_new();
ldns_rdf *qname = 0;
read_in(list, &qname, stdin);
/* check covers */
covertests(list, qname);
for(i=0; i<ldns_rr_list_rr_count(list); ++i)
{
ldns_rr* rr = ldns_rr_list_rr(list, i);
if(!ldns_dname_is_subdomain(qname, ldns_rr_owner(rr))) {
covertests(list, ldns_rr_owner(rr));
}
}
ldns_rr_list_deep_free(list);
return 0;
}
TEST(Parser, ParseMpqClass)
{
{
std::stringstream read_in("-45/90");
mpq_class val;
EXPECT_TRUE(parse_mpq_class(read_in, val));
EXPECT_EQ(-1/2_mpq, val);
}
{
std::stringstream read_in("67");
mpq_class val;
EXPECT_TRUE(parse_mpq_class(read_in, val));
EXPECT_EQ(67_mpq, val);
}
}
int main (int argc,char **argv)
{
extern char *inputfile,*initfile,*outputfile;
int input_array_int[10];
double input_array[10];
int error;
error=MPI_Init (&argc, &argv); //MPI INITIALIZE
com=MPI_COMM_WORLD;
if(error!=MPI_SUCCESS){
printf("MPI could not be initialized.\n");
exit(1);
}
MPI_Comm_size (com, &size);
MPI_Comm_rank (com, &rank);
if(argc != 4) usage(); //VERIFICATION OF INPUT FILES
if (rank == 0)
{
initfile=argv[1]; //ASIGNATION
inputfile=argv[2]; //OF FILE'S
outputfile=argv[3]; //NAMES
create_remove_dir(); //REMOVE OLD outputfile AND CREATE A NEW ONE
read_in(input_array_int,input_array); //READ INITIAL CONDITIONS
}
MPI_Bcast(input_array_int, 2 , MPI_INT, 0 , com);
MPI_Bcast(input_array, 6 , MPI_DOUBLE, 0 , com);
Num_par = input_array_int[0]; //NUMBER OF PARTICLES IN THE SIMULATION
INTEGRATOR = input_array_int[1]; //INTEGRATOR ELECTION
t = input_array[0]; //TIMESTEP
G = input_array[1]; //GRAVITATION CONSTANT
w = input_array[2]; //STAR'S ROTATION
Num_archive = input_array[3]; //NUMBER OUTPUT ARCHIVES
Num_simulation= input_array[4]; //NUMBER OF INTEGRATION FOR ARCHIVE
EPS = input_array[5]; //SOFTENING
allocate_memory(); //ALLOCATE THE MEMORY
if (rank == 0) read_input(); //READ INITIAL POSITIONS AND VELOCITIES
Bcast_part_struct(0); //MASTER MAKE A BROADCAST OF INITIAL POSITIONS AND VELOCITIES
emulator(); //SIMULATION
free_memory(); //FREE THE MEMORY
error=MPI_Finalize(); //END OF MPI
return error;
}
TEST(Parser, ParseMatrix)
{
std::stringstream read_in("2 3 1 2/5 3 -4 5 -6/2");
MatrixQ result;
EXPECT_TRUE(parse_matrix(read_in, result));
MatrixQ expected = {{1_mpq, 2/5_mpq, 3_mpq}, {-4_mpq, 5_mpq, -6/2_mpq}};
EXPECT_EQ(expected, result);
}
TEST(Parser, EatWhitespace)
{
std::stringstream read_in(" \r\n\t abc");
eat_whitespace(read_in);
std::string abc;
read_in >> abc;
EXPECT_EQ("abc", abc);
}
static inline void safe_read_in (netbuffer_t *H, char *data, int len) {
assert (read_in (H, data, len) == len);
int i;
for (i = 0; i < len; i++) {
if (data[i] == 0) {
data[i] = ' ';
}
}
}
/* 主函数 */
int main(int argc, char *argv[])
{
if (catch_signal(SIGINT, handle_shutdown) == -1)
error("Can't set the interrupt handler");// 如果有人按了Ctrl-C就调用handle_shutdown()。
listener_d = open_listener_socket();// 创建套接字。
bind_to_port(listener_d, 30000);
if (listen(listener_d, 10) == -1) {// 把监听长度设为10。
error("listen error: ");
}
struct sockaddr_storage client_addr;
unsigned int address_size = sizeof(client_addr);
puts("Waiting for connection");
char buf[255];
while (1) {// 需要循环“接受连接，然后开始对话”。
int connect_d = accept(listener_d, (struct sockaddr *)&client_addr, &address_size);// 接受来自客户端的连接。
if (connect_d == -1) {
error("connect error:");
}
if (!fork()) {// 创建子进程，如果fork()调用返回0，就说明你在子进程中。
close(listener_d);// 在子进程中，需要关闭主监听套接字。子进程只用connect_d套接字和客户端通信。
if (say(connect_d, "Internet Knock-Knock Server \r\nVersion 1.0\r\nKnock! Knock!\r\n>") != -1){
read_in(connect_d, buf, sizeof(buf));
if (strncasecmp("Who's there?", buf, 12))
say(connect_d, "You should say 'Who's there?' !");
else {
if (say(connect_d, "Oscar\r\n>") != -1) {
read_in(connect_d, buf, sizeof(buf));
if (strncasecmp("Oscar who?", buf, 10))
say(connect_d, "You should say 'Oscar who?' !\r\n");
else
say(connect_d, "Oscar silly question, you set a silly answer\r\n");
}
}
}
close(connect_d);// 一旦通信结束，子进程就可以关闭通信套接字了。
exit(0);// 通信结束以后，子进程应该退出程序。这样就能防止子进程进入服务器的主循环。
}
close(connect_d);
}
return 0;
}
/*
***************************************************************************
* Read voltage input statistics.
*
* IN:
* @a Activity structure.
*
* OUT:
* @a Activity structure with statistics.
***************************************************************************
*/
__read_funct_t wrap_read_in(struct activity *a)
{
struct stats_pwr_in *st_pwr_in
= (struct stats_pwr_in *) a->_buf0;
/* Read voltage input stats */
read_in(st_pwr_in, a->nr);
return;
}
/*
* Grab stage1 from the specified device file descriptor.
*/
static int
read_stage1_from_disk(int dev_fd, char *stage1_buf)
{
assert(stage1_buf != NULL);
if (read_in(dev_fd, stage1_buf, SECTOR_SIZE, 0) != BC_SUCCESS) {
perror(gettext("Unable to read stage1 from disk"));
return (BC_ERROR);
}
return (BC_SUCCESS);
}
int main(int argc, char *argv[])
{
if(catch_signal(SIGINT, handle_shutdown) == -1)
error("Can't set the interrupt handler.");
listener_d = open_listener_socket();
bind_to_port(listener_d, 30000);
if(listen(listener_d, 10) == -1)
error("Can't listen.");
struct sockaddr_storage client_addr;
unsigned int address_size = sizeof(client_addr);
puts("Waiting for connection.");
char buf[255];
// This version of the server forks a new seperate child process to each client.
while(1) {
int connect_d = accept(listener_d, (struct sockaddr*) &client_addr, &address_size);
if(connect_d == -1)
error("Can't open secondary socket.");
if(!fork()) {
close(listener_d);
if(say(connect_d,
"Temperature sensor ready\r\n") != -1) {
read_in(connect_d, buf, sizeof(buf));
logger(buf);
if(strncasecmp("READDATA", buf, 8)) {
}
else {
say(connect_d, "1: temp data in JSON format\r\n");
say(connect_d, "2: temp data in JSON format\r\n");
say(connect_d, "3: temp data in JSON format\r\n");
}
/*
else {
if(say(connect_d, "Oscar\r\n> ") != -1) {
read_in(connect_d, buf, sizeof(buf));
if(strncasecmp("Oscar who?", buf, 10))
say(connect_d, "You should say 'Oscar who?'!\r\n");
else
say(connect_d, "Oscar silly question, you get a silly answer.\r\n");
}
}
*/
}
close(connect_d);
exit(0);
}
close(connect_d);
}
return 0;
}
static int rpcc_process_nonce_packet (struct connection *c) {
struct rpcc_data *D = RPCC_DATA(c);
static struct rpc_nonce_packet P;
int res;
if (D->packet_num != -2 || D->packet_type != RPC_NONCE) {
return -2;
}
if (D->packet_len != sizeof (struct rpc_nonce_packet)) {
return -3;
}
assert (read_in (&c->In, &P, D->packet_len) == D->packet_len);
vkprintf (2, "Processing nonce packet, crypto schema: %d, key select: %d\n", P.crypto_schema, P.key_select);
switch (P.crypto_schema) {
case RPC_CRYPTO_NONE:
if (P.key_select) {
return -3;
}
if (D->crypto_flags & 1) {
#ifdef AES
if (D->crypto_flags & 2) {
release_all_unprocessed (&c->Out);
}
#endif
D->crypto_flags = 1;
} else {
return -5;
}
break;
#ifdef AES
case RPC_CRYPTO_AES:
if (!P.key_select || P.key_select != get_crypto_key_id ()) {
return -3;
}
if (!(D->crypto_flags & 2)) {
return -5;
}
if (abs (P.crypto_ts - D->nonce_time) > 30) {
return -6; //less'om
}
res = RPCC_FUNC(c)->rpc_start_crypto (c, P.crypto_nonce, P.key_select);
if (res < 0) {
return -6;
}
break;
#endif
default:
return -4;
}
vkprintf (2, "Processed nonce packet, crypto flags = %d\n", D->crypto_flags);
return 0;
}
int main()
{
char string[101];
printf("Enter upto 100 characters:\n");
read_in(string, 100);
printf("Before: %s\n", string);
rm_vowels(string);
printf(" After: %s\n", string);
return 0;
}
int main(int argc, char* argv[])
{
if (signal(SIGINT, handle_shutdown) == SIG_ERR) /* SIGINT = ctrl-c = intr */
error("Can't set the interrupt handler");
listener_d = open_listener_socket();
bind_to_port(listener_d, 30000);
if (listen(listener_d, 10) == -1) /* 监听连接 */
error("Can't listen");
struct sockaddr_storage client_addr;
unsigned int address_size = sizeof client_addr;
puts("Waiting for connection");
char buf[255];
for(;;) {
int connect_d = accept(listener_d, (struct sockaddr *)&client_addr,
&address_size);
if (connect_d == -1)
error("Can't open secondary socket");
if ( !fork()) { /* 这里会检查连接时的进程号，如果返回值为0则表示该进程是子进程需要在操作，否者跳过 */
if (say(connect_d, "Internet Knock-Knock Protocol Server\r\nVersion 1.0\r\nKnock! Knock!\r\n> ") != -1) { /* 向客户端发送数据 */
/* 上面这行就决定你一开是会看到什么 */
read_in(connect_d, buf, sizeof(buf));
if (strncasecmp("Who's there?", buf, 12)) /* 比较 buf 变量的值是否为 who's there? 这里就决定你输入什么才是正确的 */
say(connect_d, "You should say 'Who's there?'!");
else {
if (say(connect_d, "Oscar\r\n> ") != -1) {
read_in(connect_d, buf, sizeof(buf));
if (strncasecmp("Oscar who?", buf, 10))
say(connect_d, "You should say 'Oscar who?'!\r\n");
else
say(connect_d, "Oscar silly question, you get a silly answer\r\n");
}
}
}
close(connect_d);
exit(0);
}
close(connect_d);
}
return 0;
}
int memcache_store (struct connection *c, int op, const char *key, int key_len, int flags, int delay, int size) {
int user_id, cat = 0, friend_id = 0, i;
privacy_key_t privacy_key = 0;
if (verbosity > 0) {
fprintf (stderr, "mc_store: op=%d, key=\"%s\", flags=%d, delay=%d, bytes=%d\n", op, key, flags, delay, size);
}
if (binlog_disabled == 2) {
return -2;
}
if (reverse_friends_mode) {
if (op == mct_set && key_len >= 8 && !strncmp (key, "userlist", 8)) {
return exec_store_userlist (c, key, key_len, size);
}
return 0;
}
if (op == mct_set && sscanf (key, "friends%d_%d", &user_id, &cat) == 2 && user_id > 0 && cat > 0 && cat < 32) {
int s = parse_list (R, MAX_RES, &c->In, size);
int res = 0;
if (s >= 0) {
res = do_set_category_friend_list (user_id, cat, R, s);
}
if (verbosity > 0) {
fprintf (stderr, "set friend cat list: size = %d, res = %d\n", s, res);
}
return res;
}
if (size > 1024) {
return -2;
}
assert (read_in (&c->In, stats_buff, size) == size);
stats_buff[size] = 0;
if (sscanf (key, "friendreq%d_%d", &user_id, &friend_id) == 2 && user_id > 0 && friend_id > 0) {
return do_add_friend_request (user_id, friend_id, atol(stats_buff), (op == mct_add) * 2 + (op == mct_set)) >= 0;
}
if (op != mct_add && sscanf (key, "friend%d_%d", &user_id, &friend_id) == 2 && user_id > 0 && friend_id > 0) {
return do_add_friend (user_id, friend_id, atol(stats_buff), 0, op == mct_set);
}
if (op != mct_add && sscanf (key, "privacy%d_%n", &user_id, &i) >= 1 && user_id > 0 && parse_privacy_key (key+i, &privacy_key, 1) > 0) {
return do_set_privacy (user_id, privacy_key, stats_buff, size, op == mct_set);
}
return 0;
}
int get_saved_userlist (struct connection *c, int list_id) {
if (!c->Tmp) {
return -1;
}
struct keep_mc_header *D = (struct keep_mc_header *) c->Tmp->start;
advance_read_ptr (c->Tmp, sizeof (struct keep_mc_header));
int res = D->num;
assert (read_in (c->Tmp, userlist, res * 4) == 4 * res);
if (D->list_id != list_id) {
return -1;
}
return res;
}
void list_implementation()//list implementation
{
list<Question> all_problems;
list<Question> problems;
list<Question>::iterator l_itr;
vector<Question> temp;
int correct_count = 0;
ifstream myfile;
myfile.open ("Testfile.txt");
Question read_in("Temp", 1, "answ1", "answ2","answ3");
for(int i=0;i<15;++i)//reads in to list
{
myfile>>read_in;
all_problems.push_back(read_in);
}
for(l_itr=all_problems.begin(); l_itr != all_problems.end();++l_itr)//converts to vector to shuffle
{
temp.push_back(*l_itr);
}
srand(time(0));//ensures truly random shuffle by seeding system time
random_shuffle(temp.begin(),temp.end());//shuffles temp vector
for(int i=0;i<10;++i)//reads into new list
{
problems.push_back(temp[i]);
}
cout<<"Loop here\n";
for(l_itr=problems.begin(); l_itr != problems.end() ;++l_itr)//asks question + gets answers
{
bool correct = false;
int answer = 0;
string input;
cout<<*l_itr;
cin>>input;
if(!is_number(input) || StringToNumber(input)<0 || StringToNumber(input)>5)
throw runtime_error("Bad answer input");
else
answer = StringToNumber(input);
if(answer == l_itr->correct_answer_num())
{
++correct_count;
cout<<"Awesome work! onto the next question\n";
}
else
cout<<"Aw too bad you missed that one, try another!\n";
}
if(correct_count>6)
cout<<"You got "<<correct_count<<" Right, and passed Nice job!\n";
else
cout<<"You got "<<correct_count<<" Right, and failed, better luck next time\n";
return;
}
int main (int argc, char *argv[]) {
if (catch_signal (SIGINT, handle_shutdown) == -1)
error ("割り込みハンドラを設定できません。");
listener_d = open_listener_socket ();
bind_to_port (listener_d, 30000);
if (listen (listener_d, 10) == -1)
error ("接続待できません。");
struct sockaddr_storage client_addr;
unsigned int address_size = sizeof (client_addr);
puts ("接続を待っています。");
char buf[256];
while (1) {
int connect_d = accept (listener_d, (struct sockaddr*)&client_addr, &address_size);
if (connect_d == -1)
error ("第2のソケットを開けません。");
if (!fork()) {
close (!fork());
if (say (connect_d, "インターネット ノックノックプロトコル\r\nバージョン1.0\r\n") != -1) {
read_in (connect_d, buf, sizeof (buf));
if (strncasecmp ("Who's there?", buf, 12))
say (connect_d, "「Who's there?」と入力しなければいけません。");
else {
if (say (connect_d, "Oscar\r\n") != -1) {
read_in (connect_d, buf, sizeof (buf));
if (strncasecmp ("Oscar who?", buf, 10))
say (connect_d, "「Who's there?」と入力しなければいけません。");
else
say (connect_d, "Oscar silly question, you'll get silly answer.");
}
}
}
close (connect_d);
exit (0);
}
close (connect_d);
}
return 0;
}
int main(int argc, char **argv) {
int i = 0, j = 0, k = 0;
alloc_puzzle();
read_in();
printf("\n\nPuzzle as read in:\n");
print_puzzle();
alloc_cand();
while (!solved()) {
if (i == 2) {
printf("\nno luck after 20 iterations...\nis the puzzle solvable?\nexiting...\n");
free_mem();
exit(EXIT_SUCCESS);
}
i++;
cand();
printf("\nPuzzle after iteration #%d\n", i);
print_puzzle();
/*
if (i == 50) {
printf("num candidates\n");
for (j = 0; j < N; j++)
for (k = 0; k < N; k++)
printf("%d_%d: %d\n", j, k, puz_can[j][k][0]);
}
*/
reset();
}
/*
cand();
printf("\nPuzzle after one candidacy:\n");
print_puzzle();
reset();
cand();
printf("\nPuzzle after two candidacies:\n");
print_puzzle();
reset();
cand();
printf("\nPuzzle after three candidacies:\n");
print_puzzle();
*/
return EXIT_SUCCESS;
}
int rpcc_default_execute (struct connection *c, int op, int len) {
vkprintf (1, "rpcc_execute: fd=%d, op=%d, len=%d\n", c->fd, op, len);
if (op == RPC_PING && len == 24) {
c->last_response_time = precise_now;
static int Q[12];
assert (read_in (&c->In, Q, 24) == 24);
static int P[12];
P[0] = 24;
P[1] = RPCC_DATA(c)->out_packet_num++;
P[2] = RPC_PONG;
P[3] = Q[3];
P[4] = Q[4];
P[5] = compute_crc32 (P, 20);
vkprintf (1, "Received ping from fd=%d. ping_id = %lld. Sending pong\n", c->fd, *(long long *)(Q + 3));
write_out (&c->Out, P, 24);
RPCC_FUNC(c)->flush_packet(c);
return 24;
}
return SKIP_ALL_BYTES;
}
int rpcs_execute (struct connection *c, int op, int len) {
vkprintf (3, "rpcs_execute: fd=%d, op=%x, len=%d\n", c->fd, op, len);
if (len > MAX_PACKET_LEN) {
return SKIP_ALL_BYTES;
}
assert (read_in (&c->In, &P, len) == len);
len -= 16;
switch (op) {
case COPYEXEC_RPC_TYPE_HANDSHAKE:
return rpc_execute_handshake (c, (struct copyexec_rpc_handshake *) (P + 3), len);
case COPYEXEC_RPC_TYPE_SEND_DATA:
return rpc_execute_send_data (c, (struct copyexec_rpc_send_data *) (P + 3), len);
case COPYEXEC_RPC_TYPE_PING:
return rpc_execute_ping (c);
}
return -__LINE__;
}
void vector_implementation()//Vector implementation
{
vector<Question> vec_problems;
int correct_count = 0;
ifstream myfile_vec;
myfile_vec.open ("Testfile.txt");
Question read_in("Temp", 1, "answ1", "answ2","answ3");
for(int i=0;i<15;++i)//reads in to vector
{
myfile_vec>>read_in;
vec_problems.push_back(read_in);
}
srand(time(0));//ensures truly random shuffle by seeding system time
random_shuffle(vec_problems.begin(),vec_problems.end());//shuffles vector
for(int i=0;i<10;++i)//asks question + gets answer
{
bool correct = false;
int answer = 0;
string input;
cout<<vec_problems[i];
cin>>input;
if(!is_number(input) || StringToNumber(input)<0 || StringToNumber(input)>5)
throw runtime_error("Bad answer input");
else
answer = StringToNumber(input);
if(answer == vec_problems[i].correct_answer_num())
{
++correct_count;
cout<<"Awesome work! onto the next question\n";
}
else
cout<<"Aw too bad you missed that one, try another!\n";
}
if(correct_count>6)
cout<<"You got "<<correct_count<<" Right, and passed Nice job!\n";
else
cout<<"You got "<<correct_count<<" Right, and failed, better luck next time\n";
return;
}
// all tests will us a stringstream as an input
TEST_F(TestReadin, test_read_in_int){
std::stringstream s;
s << 1;
int res = read_in(s, correct_int, "");
EXPECT_EQ(1, res);
}
static int
read_stage2_from_disk(int dev_fd, ig_stage2_t *stage2, int type)
{
uint32_t size;
uint32_t buf_size;
uint32_t mboot_off;
multiboot_header_t *mboot;
assert(stage2 != NULL);
assert(dev_fd != -1);
if (read_in(dev_fd, mboot_scan, sizeof (mboot_scan),
STAGE2_BLKOFF(type) * SECTOR_SIZE) != BC_SUCCESS) {
perror(gettext("Error reading stage2 sectors"));
return (BC_ERROR);
}
/* No multiboot means no chance of knowing stage2 size */
if (find_multiboot(mboot_scan, sizeof (mboot_scan), &mboot_off)
!= BC_SUCCESS) {
BOOT_DEBUG("Unable to find multiboot header\n");
return (BC_NOEXTRA);
}
mboot = (multiboot_header_t *)(mboot_scan + mboot_off);
/*
* Unfilled mboot values mean an older version of installgrub installed
* the stage2. Again we have no chance of knowing stage2 size.
*/
if (mboot->load_end_addr == 0 ||
mboot->load_end_addr < mboot->load_addr)
return (BC_NOEXTRA);
/*
* Currently, the amount of space reserved for extra information
* is "fixed". We may have to scan for the terminating extra payload
* in the future.
*/
size = mboot->load_end_addr - mboot->load_addr;
buf_size = P2ROUNDUP(size + SECTOR_SIZE, SECTOR_SIZE);
stage2->buf = malloc(buf_size);
if (stage2->buf == NULL) {
perror(gettext("Memory allocation failed"));
return (BC_ERROR);
}
stage2->buf_size = buf_size;
if (read_in(dev_fd, stage2->buf, buf_size, STAGE2_BLKOFF(type) *
SECTOR_SIZE) != BC_SUCCESS) {
perror("read");
free(stage2->buf);
return (BC_ERROR);
}
/* Update pointers. */
stage2->file = stage2->buf;
stage2->file_size = size;
stage2->mboot_off = mboot_off;
stage2->mboot = (multiboot_header_t *)(stage2->buf + stage2->mboot_off);
stage2->extra = stage2->buf + P2ROUNDUP(stage2->file_size, 8);
stage2->extra_size = stage2->buf_size - P2ROUNDUP(stage2->file_size, 8);
return (BC_SUCCESS);
}
int memcache_store (struct connection *c, int op, const char *key, int key_len, int flags, int delay, int size) {
cmd_set++;
inode_id_t inode;
unsigned int offset = 0;
int act = 0;
int x = 0, y = 0;
struct fuse_file_info fi;
if (size < MAX_VALUE_LEN && key_len > 0 && op == mct_set) {
switch (*key) {
case 'c':
if (!strncmp (key, "chmod", 5) && sscanf (key, "chmod%d", &x) >= 1) {
act = 6;
}
if (!strncmp (key, "chown", 5) && sscanf (key, "chown%d,%d", &x, &y) >= 2) {
act = 7;
}
break;
case 'm':
if (!strncmp (key, "mkdir", 5) && sscanf (key, "mkdir%d", &x) >= 1) {
act = 1;
}
break;
case 'p':
if (!strcmp (key, "path")) {
act = 3;
}
case 'r':
if (!strcmp (key, "rmdir")) {
act = 4;
}
case 'w':
if (sscanf (key, "write%u,%lld", &offset, &inode) >= 2) {
act = 2;
}
break;
case 'u':
if (!strcmp (key, "unlink")) {
act = 5;
}
}
int r = -11;
if (act) {
assert (read_in (&c->In, value_buff, size) == size);
value_buff[size] = 0;
switch (act) {
case 1:
r = ff_mkdir (value_buff, x);
break;
case 2:
fi.fh = inode;
r = ff_write (NULL, value_buff, size, offset, &fi);
if (r >= 0) {
r = 0;
}
break;
case 3:
init_tmp_buffers (c);
write_out (c->Tmp, &size, sizeof (size));
write_out (c->Tmp, value_buff, size);
r = 0;
break;
case 4:
r = ff_rmdir (value_buff);
break;
case 5:
r = ff_unlink (value_buff);
break;
case 6:
r = ff_chmod (value_buff, x);
break;
case 7:
r = ff_chown (value_buff, x, y);
break;
}
if (!r) {
return 1;
}
if (verbosity > 0 && r < 0) {
fprintf (stderr, "store: fail (act = %d, res = %d)\n", act, r);
}
return 0;
}
}
return -2;
}
int main(int argc, char **argv){
FILE *file = fopen("file1","r");
FILE *out = NULL;
char str_buf[1024][50];
unsigned str_buf_in = 0;
unsigned str_buf_out = 0;
char str[50];
int read_finish = 0;
int num_read = 0, num_write = 0;
char **input_filenames = NULL;
int input_len; //num of input files
FILE **input_files = NULL;
int i,j; double elapsed_time;
int mapping_done = 0;//done when all mapper thread done
struct timeval tvalBefore, tvalAfter;
////locks///
int rank, size, len;
char name[MPI_MAX_PROCESSOR_NAME];
omp_set_num_threads(4);
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Get_processor_name(name, &len);
MPI_Status status;
omp_init_lock(&worklock);
omp_init_lock(&inclock);
omp_init_lock(&readlock);
omp_init_lock(&readerlock);
omp_init_lock(&mapperlock);
if(argc < 5){
printf("Usage ./mapreduce -in [input files].... -out [output file]\n");
return 0;
}else{
if(strcmp("-in",argv[1])){
printf("Usage ./mapreduce -in [input files].... -out [output file]\n");
return 0;
}
for(i=2;i<argc;i++){ //start from first input file
if(!strcmp("-out",argv[i])){
break;
}
}
input_len = i - 2;
input_filenames = (char**)malloc(sizeof(char*)*input_len);
for(j=0;j<input_len;j++)
input_filenames[j] = (char*)malloc(sizeof(char)*50);
for(i=2,j=0;j<input_len;i++,j++){
strcpy(input_filenames[j],argv[i]);
}
input_files = read_in(input_filenames,input_len,0);
if(strcmp("-out",argv[2+input_len])){
printf("output file missing, using default name 'out'\n");
out = fopen("out","w");
}else{
out = fopen(argv[3+input_len],"w");
}
}
omp_set_num_threads(8);
fifoQ *queue_to_map = initQ(1000000, "queue_to_map");
fifoQ *queue_to_reduce = initQ(1000000, "queue_to_map");
fifoQ **queues_to_map = (fifoQ**)malloc(sizeof(fifoQ*)*5);
queues_to_map[0] = initQ(1000000, "queue_to_map0");
queues_to_map[1] = initQ(1000000, "queue_to_map1");
queues_to_map[2] = initQ(1000000, "queue_to_map2");
queues_to_map[3] = initQ(1000000, "queue_to_map3");
queues_to_map[4] = initQ(1000000, "queue_to_map4");
fifoQ **queues_to_reduce = (fifoQ**)malloc(sizeof(fifoQ*)*5);
queues_to_reduce[0] = initQ(1000000, "queue_to_reduce0");
queues_to_reduce[1] = initQ(1000000, "queue_to_reduce1");
queues_to_reduce[2] = initQ(1000000, "queue_to_reduce2");
queues_to_reduce[3] = initQ(1000000, "queue_to_reduce3");
queues_to_reduce[4] = initQ(1000000, "queue_to_reduce4");
fifoQ **queues_reduced = (fifoQ**)malloc(sizeof(fifoQ*)*5);
fifoQ *final_queue = initQ(1000000, "final Q");
int sendsize = input_len/size + (input_len % size - rank > 0 ? 1 : 0); //num of files send to a node
if(rank==0){ //distribute files
int i,j;
char ***files_tosend = (char***)malloc(sizeof(char**)*input_len);
int lsendsize;
FILE **node_files;
for(i=0;i<size;i++){
lsendsize = input_len/size + (input_len % size - i > 0 ? 1 : 0); //num of files send to a node
printf("send size of core %d is %d\n",i,lsendsize);
files_tosend[i] = (char**)malloc(sizeof(char*)*lsendsize);
for(j=0;j<lsendsize;j++){
files_tosend[i][j] = (char*)malloc(sizeof(char)*50);
}
}
for(i=0;i<input_len;i++){
int belongs_to = i % size;
int pos = i/size;
strcpy(files_tosend[belongs_to][pos],input_filenames[i]);
printf("distributing file %s to files_tosend %d,%d, value %s\n",input_filenames[i],belongs_to,pos,files_tosend[belongs_to][pos]);
}
if(size>1){
for(i=1;i<size;i++){
lsendsize = input_len/size + (input_len % size - i > 0 ? 1 : 0);
for(j=0;j<lsendsize;j++){
printf("sending %s to cpu %d\n",files_tosend[i][j],i);
MPI_Send(files_tosend[i][j],50,MPI_BYTE,i,1,MPI_COMM_WORLD);
printf("send done\n");
}
}
}
node_files = (FILE**)malloc(sizeof(FILE*)*sendsize);
for(i=0;i<sendsize;i++){
node_files[i] = fopen(files_tosend[rank][i],"r");
}
gettimeofday (&tvalBefore, NULL);
#pragma omp parallel sections
{
#pragma omp section //reader thread0
{
int i; int odd_even = 0;
//printf("reader 0 is core #%d\n",rank);
for(i=0;i<sendsize;i++){
while(!feof(node_files[i])){
/////////check if full///////////
omp_set_lock(&readerlock);
if(!feof(node_files[i])){
strcpy(str,"");
fscanf(node_files[i],"%s",str);
}
else{
omp_unset_lock(&readerlock);
break;
}
omp_unset_lock(&readerlock);
if(strcmp(str,""))
putWork(queues_to_map[0], constr_work(str));
}
}
omp_set_lock(&inclock);
read_finish++;
omp_unset_lock(&inclock);
//printf("reader thread0 done\n");
}
#pragma omp section //reader thread1
{
int i; int odd_even = 0;
//printf("reader 1 is core #%d\n",rank);
for(i=0;i<sendsize;i++){
while(!feof(node_files[i])){
/////////check if full///////////
omp_set_lock(&readerlock);
if(!feof(node_files[i])){
strcpy(str,"");
fscanf(node_files[i],"%s",str);
}
else{
omp_unset_lock(&readerlock);
break;
}
omp_unset_lock(&readerlock);
if(strcmp(str,""))
putWork(queues_to_map[1], constr_work(str));
}
}
omp_set_lock(&inclock);
read_finish++;
omp_unset_lock(&inclock);
//printf("reader thread1 done\n");
}
#pragma omp section //reader thread2
{
int i; int odd_even = 0;
//printf("reader 2 is core #%d\n",rank);
for(i=0;i<sendsize;i++){
while(!feof(node_files[i])){
/////////check if full///////////
omp_set_lock(&readerlock);
if(!feof(node_files[i])){
strcpy(str,"");
fscanf(node_files[i],"%s",str);
}
else{
omp_unset_lock(&readerlock);
break;
}
omp_unset_lock(&readerlock);
if(strcmp(str,""))
putWork(queues_to_map[2], constr_work(str));
}
}
omp_set_lock(&inclock);
read_finish++;
omp_unset_lock(&inclock);
//printf("reader thread2 done\n");
}
#pragma omp section //reader thread3
{
// printf("reader 3 is core #%d\n",rank);
int i; int odd_even = 0;
for(i=0;i<sendsize;i++){
while(!feof(node_files[i])){
/////////check if full///////////
omp_set_lock(&readerlock);
if(!feof(node_files[i])){
strcpy(str,"");
fscanf(node_files[i],"%s",str);
}
else{
omp_unset_lock(&readerlock);
break;
}
omp_unset_lock(&readerlock);
if(strcmp(str,""))
putWork(queues_to_map[3], constr_work(str));
}
}
omp_set_lock(&inclock);
read_finish++;
omp_unset_lock(&inclock);
//printf("reader thread3 done %d\n",rank);
}
#pragma omp section //mapper thread 0
{
int i;
fifoQ *innerQ = initQ(50000,"innerQ 0");
while(read_finish<NUM_READ_THREADS || !is_empty(queues_to_map[0])){
printf("");
if(!is_empty(queues_to_map[0])){
work work = getWork(queues_to_map[0]);
//mapper(queues_to_reduce[hash(work.str)], work);
mapper(innerQ, work);
}
}
for(i=0;i<=innerQ->in;i++){
work work = getWork(innerQ);
putWork(queues_to_reduce[hash(work.str)],work);
}
omp_set_lock(&inclock);
mapping_done++;
omp_unset_lock(&inclock);
//printf("mapper thread0 done %d\n",rank);
gettimeofday (&tvalAfter, NULL);
elapsed_time = (float)(tvalAfter.tv_sec - tvalBefore.tv_sec)+((float)(tvalAfter.tv_usec - tvalBefore.tv_usec)/1000000);
if(rank==0)
printf("elapsed time = %.2f sec,rank %d in map 0\n",elapsed_time,rank);
}
#pragma omp section //mapper thread 1
{
int i;
fifoQ *innerQ = initQ(50000,"innerQ 1");
while(read_finish<NUM_READ_THREADS || !is_empty(queues_to_map[1])){
printf("");
if(!is_empty(queues_to_map[1])){
work work = getWork(queues_to_map[1]);
//mapper(queues_to_reduce[hash(work.str)], work);
mapper(innerQ, work);
}
}
for(i=0;i<=innerQ->in;i++){
work work = getWork(innerQ);
putWork(queues_to_reduce[hash(work.str)],work);
}
omp_set_lock(&inclock);
mapping_done++;
omp_unset_lock(&inclock);
//printf("mapper thread1 done %d\n",rank);
gettimeofday (&tvalAfter, NULL);
elapsed_time = (float)(tvalAfter.tv_sec - tvalBefore.tv_sec)+((float)(tvalAfter.tv_usec - tvalBefore.tv_usec)/1000000);
if(rank==0)
printf("elapsed time = %.2f sec,rank %d in map 1\n",elapsed_time,rank);
}
#pragma omp section //mapper thread 2
{
int i;
fifoQ *innerQ = initQ(50000,"innerQ 2");
while(read_finish<NUM_READ_THREADS || !is_empty(queues_to_map[2])){
printf("");
if(!is_empty(queues_to_map[2])){
work work = getWork(queues_to_map[2]);
//mapper(queues_to_reduce[hash(work.str)], work);
mapper(innerQ, work);
}
}
for(i=0;i<=innerQ->in;i++){
work work = getWork(innerQ);
putWork(queues_to_reduce[hash(work.str)],work);
}
omp_set_lock(&inclock);
mapping_done++;
omp_unset_lock(&inclock);
//printf("mapper thread2 done %d\n",rank);
gettimeofday (&tvalAfter, NULL);
elapsed_time = (float)(tvalAfter.tv_sec - tvalBefore.tv_sec)+((float)(tvalAfter.tv_usec - tvalBefore.tv_usec)/1000000);
if(rank==0)
printf("elapsed time = %.2f sec,rank %d in map 2\n",elapsed_time,rank);
}
#pragma omp section //mapper thread 3
{
int i;
fifoQ *innerQ = initQ(50000,"innerQ 2");
while(read_finish<NUM_READ_THREADS || !is_empty(queues_to_map[3])){
printf("");
if(!is_empty(queues_to_map[3])){
work work = getWork(queues_to_map[3]);
//mapper(queues_to_reduce[hash(work.str)], work);
mapper(innerQ, work);
}
}
for(i=0;i<=innerQ->in;i++){
work work = getWork(innerQ);
putWork(queues_to_reduce[hash(work.str)],work);
}
omp_set_lock(&inclock);
mapping_done++;
omp_unset_lock(&inclock);
//printf("mapper thread3 done %d\n",rank);
gettimeofday (&tvalAfter, NULL);
elapsed_time = (float)(tvalAfter.tv_sec - tvalBefore.tv_sec)+((float)(tvalAfter.tv_usec - tvalBefore.tv_usec)/1000000);
if(rank==0)
printf("elapsed time = %.2f sec,rank %d in map 3\n",elapsed_time,rank);
}
#pragma omp section //reducer thread 0
{
int i;
gettimeofday (&tvalAfter, NULL);
elapsed_time = (float)(tvalAfter.tv_sec - tvalBefore.tv_sec)+((float)(tvalAfter.tv_usec - tvalBefore.tv_usec)/1000000);
if(rank==0)
printf("elapsed time = %.2f sec,rank %d\n",elapsed_time,rank);
while(mapping_done<NUM_READ_THREADS){
printf("");
}
gettimeofday (&tvalAfter, NULL);
elapsed_time = (float)(tvalAfter.tv_sec - tvalBefore.tv_sec)+((float)(tvalAfter.tv_usec - tvalBefore.tv_usec)/1000000);
if(rank==0)
printf("elapsed time = %.2f sec,rank %d\n",elapsed_time,rank);
queues_reduced[0] = reducer(queues_to_reduce[0]);
//printf("reducer thread 0 done\n");
gettimeofday (&tvalAfter, NULL);
elapsed_time = (float)(tvalAfter.tv_sec - tvalBefore.tv_sec)+((float)(tvalAfter.tv_usec - tvalBefore.tv_usec)/1000000);
if(rank==0)
printf("elapsed time = %.2f sec,rank %d\n",elapsed_time,rank);
}
#pragma omp section //reducer thread 1
{
int i;
while(mapping_done<NUM_READ_THREADS){printf("");}
queues_reduced[1] = reducer(queues_to_reduce[1]);
//printf("reducer thread 1 done\n");
}
#pragma omp section //reducer thread 2
{
int i;
while(mapping_done<NUM_READ_THREADS){printf("");}
queues_reduced[2] = reducer(queues_to_reduce[2]);
//printf("reducer thread 2 done\n");
}
#pragma omp section //reducer thread 3
{
int i;
while(mapping_done<NUM_READ_THREADS){printf("");}
queues_reduced[3] = reducer(queues_to_reduce[3]);
//printf("reducer thread 3 done\n");
}
}
gettimeofday (&tvalAfter, NULL);
elapsed_time = (float)(tvalAfter.tv_sec - tvalBefore.tv_sec)+((float)(tvalAfter.tv_usec - tvalBefore.tv_usec)/1000000);
if(rank==0)
printf("elapsed time = %.2f sec,rank %d\n",elapsed_time,rank);
}
else{
int i;
FILE** node_files = (FILE**)malloc(sizeof(FILE*)*sendsize);
for(i=0;i<sendsize;i++){
char *bufstr = (char*)malloc(sizeof(char)*50);
MPI_Recv(bufstr,50,MPI_BYTE, 0,1, MPI_COMM_WORLD, &status);
//printf("%s received\n",bufstr);
node_files[i] = fopen(bufstr,"r");
}
#pragma omp parallel sections shared(input_files) private(str)
{
//printf("using %d threads in core %d\n",omp_get_num_threads(),rank);
#pragma omp section //reader thread0
{
int i; int odd_even = 0;
// printf("reader 0 is core #%d\n",rank);
for(i=0;i<sendsize;i++){
while(!feof(node_files[i])){
/////////check if full///////////
omp_set_lock(&readerlock);
if(!feof(node_files[i])){
strcpy(str,"");
fscanf(node_files[i],"%s",str);
}
else{
omp_unset_lock(&readerlock);
break;
}
omp_unset_lock(&readerlock);
if(strcmp(str,""))
putWork(queues_to_map[0], constr_work(str));
}
}
omp_set_lock(&inclock);
read_finish++;
omp_unset_lock(&inclock);
//printf("reader thread0 done\n");
}
#pragma omp section //reader thread1
{
int i; int odd_even = 0;
// printf("reader 1 is core #%d\n",rank);
for(i=0;i<sendsize;i++){
while(!feof(node_files[i])){
/////////check if full///////////
omp_set_lock(&readerlock);
if(!feof(node_files[i])){
strcpy(str,"");
fscanf(node_files[i],"%s",str);
}
else{
omp_unset_lock(&readerlock);
break;
}
omp_unset_lock(&readerlock);
if(strcmp(str,""))
putWork(queues_to_map[1], constr_work(str));
}
}
omp_set_lock(&inclock);
read_finish++;
omp_unset_lock(&inclock);
//printf("reader thread1 done\n");
}
#pragma omp section //reader thread2
{
int i; int odd_even = 0;
//printf("reader 2 is core #%d\n",rank);
for(i=0;i<sendsize;i++){
while(!feof(node_files[i])){
/////////check if full///////////
omp_set_lock(&readerlock);
if(!feof(node_files[i])){
strcpy(str,"");
fscanf(node_files[i],"%s",str);
}
else{
omp_unset_lock(&readerlock);
break;
}
omp_unset_lock(&readerlock);
if(strcmp(str,""))
putWork(queues_to_map[2], constr_work(str));
}
}
omp_set_lock(&inclock);
read_finish++;
omp_unset_lock(&inclock);
//printf("reader thread2 done\n");
}
#pragma omp section //reader thread3
{
//printf("reader 3 is core #%d\n",rank);
int i; int odd_even = 0;
for(i=0;i<sendsize;i++){
while(!feof(node_files[i])){
/////////check if full///////////
omp_set_lock(&readerlock);
if(!feof(node_files[i])){
strcpy(str,"");
fscanf(node_files[i],"%s",str);
}
else{
omp_unset_lock(&readerlock);
break;
}
omp_unset_lock(&readerlock);
if(strcmp(str,""))
putWork(queues_to_map[3], constr_work(str));
}
}
omp_set_lock(&inclock);
read_finish++;
omp_unset_lock(&inclock);
//printf("reader thread3 done %d\n",rank);
}
#pragma omp section //mapper thread 0
{
int i;
fifoQ *innerQ = initQ(50000,"innerQ 0");
//printf("map1\n");
while(read_finish<NUM_READ_THREADS || !is_empty(queues_to_map[0])){
printf("");
if(!is_empty(queues_to_map[0])){
work work = getWork(queues_to_map[0]);
//mapper(queues_to_reduce[hash(work.str)], work);
mapper(innerQ, work);
}
}
for(i=0;i<=innerQ->in;i++){
work work = getWork(innerQ);
putWork(queues_to_reduce[hash(work.str)],work);
}
omp_set_lock(&inclock);
mapping_done++;
omp_unset_lock(&inclock);
//printf("mapper thread0 done %d\n",rank);
}
#pragma omp section //mapper thread 1
{
int i;
fifoQ *innerQ = initQ(50000,"innerQ 1");
while(read_finish<NUM_READ_THREADS || !is_empty(queues_to_map[1])){
printf("");
if(!is_empty(queues_to_map[1])){
work work = getWork(queues_to_map[1]);
//mapper(queues_to_reduce[hash(work.str)], work);
mapper(innerQ, work);
}
}
for(i=0;i<=innerQ->in;i++){
work work = getWork(innerQ);
putWork(queues_to_reduce[hash(work.str)],work);
}
omp_set_lock(&inclock);
mapping_done++;
omp_unset_lock(&inclock);
//printf("mapper thread1 done %d\n",rank);
}
#pragma omp section //mapper thread 2
{
int i;
fifoQ *innerQ = initQ(50000,"innerQ 2");
while(read_finish<NUM_READ_THREADS || !is_empty(queues_to_map[2])){
printf("");
if(!is_empty(queues_to_map[2])){
work work = getWork(queues_to_map[2]);
//mapper(queues_to_reduce[hash(work.str)], work);
mapper(innerQ, work);
}
}
for(i=0;i<=innerQ->in;i++){
work work = getWork(innerQ);
putWork(queues_to_reduce[hash(work.str)],work);
}
omp_set_lock(&inclock);
mapping_done++;
omp_unset_lock(&inclock);
//printf("mapper thread2 done %d\n",rank);
}
#pragma omp section //mapper thread 3
{
int i;
fifoQ *innerQ = initQ(50000,"innerQ 2");
while(read_finish<NUM_READ_THREADS || !is_empty(queues_to_map[3])){
printf("");
if(!is_empty(queues_to_map[3])){
work work = getWork(queues_to_map[3]);
//mapper(queues_to_reduce[hash(work.str)], work);
mapper(innerQ, work);
}
}
for(i=0;i<=innerQ->in;i++){
work work = getWork(innerQ);
putWork(queues_to_reduce[hash(work.str)],work);
}
omp_set_lock(&inclock);
mapping_done++;
omp_unset_lock(&inclock);
//printf("mapper thread3 done %d\n",rank);
}
#pragma omp section //reducer thread 0
{
int i;
while(mapping_done<NUM_READ_THREADS){
printf("");
}
queues_reduced[0] = reducer(queues_to_reduce[0]);
//printf("reducer thread 0 done\n");
}
#pragma omp section //reducer thread 1
{
int i;
while(mapping_done<NUM_READ_THREADS){printf("");}
queues_reduced[1] = reducer(queues_to_reduce[1]);
//printf("reducer thread 1 done\n");
}
#pragma omp section //reducer thread 2
{
int i;
while(mapping_done<NUM_READ_THREADS){printf("");}
queues_reduced[2] = reducer(queues_to_reduce[2]);
//printf("reducer thread 2 done\n");
}
#pragma omp section //reducer thread 3
{
int i;
while(mapping_done<NUM_READ_THREADS){printf("");}
queues_reduced[3] = reducer(queues_to_reduce[3]);
//printf("reducer thread 3 done\n");
}
}
}
MPI_Barrier(MPI_COMM_WORLD);
gettimeofday (&tvalAfter, NULL);
elapsed_time = (float)(tvalAfter.tv_sec - tvalBefore.tv_sec)+((float)(tvalAfter.tv_usec - tvalBefore.tv_usec)/1000000);
if(rank==0)
printf("elapsed time = %.2f sec,rank %d\n",elapsed_time,rank);
if(rank==0){ //final reducuction
int i,j,revbuf;int mainct;
for(i=0;i<NUM_READ_THREADS;i++){
combine_queue(final_queue,queues_reduced[i]);
}
//printf("main node has %d to final reduce\n",calcnum(queues_reduced,NUM_READ_THREADS));
for(i=1;i<size;i++){
MPI_Recv(&revbuf,1,MPI_INT,i,1,MPI_COMM_WORLD,&status);
//printf("need to receive %d strings from node %d\n",revbuf,i);
char *strbuf = (char*)malloc(sizeof(char)*50);
char ctbuf = 0;
for(j=0;j<revbuf;j++){
MPI_Recv(strbuf,50,MPI_BYTE,i,1,MPI_COMM_WORLD,&status);
MPI_Recv(&ctbuf,50,MPI_INT,i,1,MPI_COMM_WORLD,&status);
work work;
strcpy(work.str,strbuf);
work.count = ctbuf;
//printf("received <%s,%d> from node %d\n",work.str,work.count,i);
putWork(final_queue,work);
}
}
fifoQ *output = reducer(final_queue);
printQ_to_file(&output,1,out);
}else{
int i,total_num;
total_num = calcnum(queues_reduced,NUM_READ_THREADS);
MPI_Send(&total_num,1,MPI_INT,0,1,MPI_COMM_WORLD);
for(i=0;i<NUM_READ_THREADS;i++){
combine_queue(final_queue,queues_reduced[i]);
}
for(i=0;i<total_num;i++){
MPI_Send(&final_queue->works[i].str,50,MPI_BYTE,0,1,MPI_COMM_WORLD);
MPI_Send(&final_queue->works[i].count,1,MPI_INT,0,1,MPI_COMM_WORLD);
}
}
for(i=0;i<input_len;i++){
fclose(input_files[i]);
}
fclose(out);
/*printQ(queues_to_map[0]);
printQ(queues_to_map[1]);
printQ(queues_to_map[2]);
printQ(queues_to_map[3]);*/
/*printQ(queues_reduced[0]);
printQ(queues_reduced[1]);
printQ(queues_reduced[2]);
printQ(queues_reduced[3]);*/
omp_destroy_lock(&inclock);
omp_destroy_lock(&worklock);
omp_destroy_lock(&readlock);
omp_destroy_lock(&readerlock);
omp_destroy_lock(&mapperlock);
MPI_Finalize();
return 0;
}
