void* operation_executer(void * args){ //pthread_mutex_lock(&mutex); exec_info * info = (exec_info*) args; while(*(info -> exit) == 0) { pthread_mutex_lock(&mutex); while (operations_queue_empty(info->market->stock_operations) == 1) { pthread_cond_wait(¬_operations, &mutex); } //if(operations_queue_empty(info->market->stock_operations) == 0){ dequeue_operation(info->market->stock_operations, &op); process_operation(info->market, &op); //} pthread_cond_signal(&operations); pthread_mutex_unlock(&mutex); } while(operations_queue_empty(info->market->stock_operations) == 0){ pthread_mutex_lock(&mutex); dequeue_operation(info->market->stock_operations, &op); process_operation(info->market, &op); pthread_cond_signal(&operations); pthread_mutex_unlock(&mutex); } //pthread_mutex_unlock(&mutex); pthread_exit(0); }
void task4_6::solution::process_line( std::string line ) { int eq_pos = line.find("="); const std::string& value_name = line.substr( 0, eq_pos-1 ); line = line.substr( eq_pos + 2 ); if( value.count( value_name ) ) throw std::logic_error( "such variable '"+value_name+"' already exists ("+boost::lexical_cast< std::string >( line_index )+")" ); std::stack< char > operations; std::stack< double > numbers; double result = 0; for( size_t i = 0; i < line.length(); i++) if( line[i] != ' ' ) if( line[i] == '(' ) operations.push('('); else if( line[i] ==')' ) { while( !operations.empty() && operations.top() != '(' ) { process_operation( numbers, operations.top() ); operations.pop(); } if( operations.empty() ) throw std::logic_error("not correct expression at "+boost::lexical_cast< std::string >( line_index )+" line"); operations.pop(); } else if( is_operation( line[i] ) ) { while( !operations.empty() && get_priority( operations.top() ) >= get_priority( line[i] ) ) { process_operation( numbers, operations.top() ); operations.pop(); } operations.push( line[i] ); } else { std::string operand; while (i < line.length() && line[i]!=' ' && !is_operation(line[i]) && line[i]!='(' && line[i]!=')') operand += line[i++]; --i; double to_push; parse_variable ( operand, to_push ); numbers.push ( to_push ); } while ( !operations.empty() ) { process_operation( numbers, operations.top() ); operations.pop(); } result = numbers.top(); value[ value_name ] = result; }
/* Handle a request from a client */ void *handle_request(void *ptr){ int bytes_read, bytes_write; char message[256]; struct operation operation; struct pool_list *node; int clientfd; while (1) { pthread_mutex_lock(&mutex); while (list_head == NULL) { pthread_cond_wait(&cond, &mutex); } node = list_head; list_head = node->next; pthread_mutex_unlock(&mutex); clientfd = node->fd; //for test bytes_read = read(clientfd, message, 256); if(bytes_read < 0) { perror("ERROR reading socket"); } else if (bytes_read == 0){ printf("Client disconnected"); } else { parse_message(message, bytes_read, &operation); process_operation(&operation, message, &bytes_write); write(clientfd, message, bytes_write); printf("thread: %d, received:%s\n", pthread_self(), message); } // close(clientfd); free(node); } }
void child(int id_number, int NPROC, int my_semaphores[], int p1[], int p2[]){ sem_computing = my_semaphores[0]; sem_wait_data = my_semaphores[1]; sem_request_result = my_semaphores[2]; sem_parent = my_semaphores[3]; /* support variable to perform the operation */ float res; int val1, val2, op_id; char op; //################################################### int childs_ready; //################################################### /* sem_parent inizialized to {1, 0, 0}: * 0: mutex * 1: result_ready * 2: data_read */ sem_p(sem_parent, 0); //#################################################### //# read(p1[0], &childs_ready, sizeof(childs_ready)); childs_ready++; write(p2[1], &childs_ready, sizeof(childs_ready)); //# //#################################################### /* the last child will unlock the parent */ if(childs_ready == NPROC) sem_v(sem_parent, 1); sem_v(sem_parent, 0); print_child_info("[Child %d] ready!\n", id_number); while(true) { //child_isFree[id_number] = true; // si mette in attesa di essere chiamato per il calcolo sem_p(sem_wait_data, id_number); /* make this child busy */ //child_isFree[id_number] = false; /* read data sent from parent */ print_child_info("[Child %d] unlocked from parent, reading data...\n", id_number); read(p1[0], &op_id, sizeof(op_id)); read(p1[0], &val1, sizeof(val1)); read(p1[0], &val2, sizeof(val2)); read(p1[0], &op, sizeof(op)); //val1 = current_operation->val1; //val2 = current_operation->val2; /***************************/ //op = current_operation->operator; /***** CRITICAL SECTION ****/ //op_id = current_operation->id; /***************************/ // avvisa che ho finito di leggere sem_v(sem_parent, 2); // termina col comando k if(op == 'k'){ print_child_info("[Child %d] read: 'k' exiting...\n", id_number); return; } print_operation_info("[Child %d] read: %d %c %d\n", id_number,val1,op,val2); // calcola print_child_info("[Child %d] processing operation...\n", id_number); res = process_operation(val1, val2, op); // avvisa di aver terminato il calcolo sem_v(sem_computing, id_number); // calcolo terminato print_child_info("[Child %d] wait parent for request of result...\n", id_number); // attende che il padre richieda i dati sem_p(sem_request_result, id_number); print_child_info("[Child %d] write the result...\n", id_number); //scrivi risultato calcolo /****************************/ //current_result->val = res; /***** CRITICAL SECTION *****/ //current_result->id = op_id; /****************************/ write(p2[1], &op_id, sizeof(op_id)); write(p2[1], &res, sizeof(res)); print_child_info("[Child %d] result ready to be read!\n", id_number); // dice al padre che i dati sono pronti per essere letti sem_v(sem_parent, 1); } }
void server_control_executor::operator()() { int port = 0, num_hash_rounds = 0; buffer_crypt::array_t shared_secret; std::string encryption_algorithm; error ret = get_server_properties( port_prop_, port, num_hash_rounds, shared_secret, encryption_algorithm ); if ( !ret.ok() ) { irods::log( PASS( ret ) ); return; } if ( shared_secret.empty() || encryption_algorithm.empty() || 0 == port || 0 == num_hash_rounds ) { rodsLog( LOG_NOTICE, "control plane is not configured properly" ); return; } zmq::context_t zmq_ctx( 1 ); zmq::socket_t zmq_skt( zmq_ctx, ZMQ_REP ); int time_out = SERVER_CONTROL_POLLING_TIME_MILLI_SEC; zmq_skt.setsockopt( ZMQ_RCVTIMEO, &time_out, sizeof( time_out ) ); zmq_skt.setsockopt( ZMQ_SNDTIMEO, &time_out, sizeof( time_out ) ); std::stringstream port_sstr; port_sstr << port; std::string conn_str( "tcp://*:" ); conn_str += port_sstr.str(); zmq_skt.bind( conn_str.c_str() ); rodsLog( LOG_NOTICE, ">>> control plane :: listening on port %d\n", port ); server_state& s = server_state::instance(); while ( server_state::STOPPED != s() ) { zmq::message_t req; zmq_skt.recv( &req ); if ( 0 == req.size() ) { continue; } // process the message std::string output; std::string rep_msg( SERVER_CONTROL_SUCCESS ); error ret = process_operation( req, output ); if ( !ret.ok() ) { log( PASS( ret ) ); rep_msg = ret.result(); } else if ( !output.empty() ) { rep_msg = output; } buffer_crypt crypt( shared_secret.size(), // key size 0, // salt size ( we dont send a salt ) num_hash_rounds, // num hash rounds encryption_algorithm.c_str() ); buffer_crypt::array_t iv; buffer_crypt::array_t data_to_send; buffer_crypt::array_t data_to_encrypt( rep_msg.begin(), rep_msg.end() ); ret = crypt.encrypt( shared_secret, iv, data_to_encrypt, data_to_send ); if ( !ret.ok() ) { irods::log( PASS( ret ) ); } zmq::message_t rep( data_to_send.size() ); memcpy( rep.data(), data_to_send.data(), data_to_send.size() ); zmq_skt.send( rep ); } // while } // control operation