void
test_AppendQueues(void) {
queue* q1 = create_queue();
queue* q2 = create_queue();
queue* q3 = create_queue();
queue* q4 = create_queue();
queue* q5 = create_queue();
// append empty queue to empty queue
append_queue(q1, q2); // destroys q2
element *e1_ptr, *e2_ptr, *e3_ptr, *e4_ptr, *e5_ptr, *e6_ptr;
e1_ptr = (element*)debug_get_node(sizeof(element));
e2_ptr = (element*)debug_get_node(sizeof(element));
e3_ptr = (element*)debug_get_node(sizeof(element));
e4_ptr = (element*)debug_get_node(sizeof(element));
e5_ptr = (element*)debug_get_node(sizeof(element));
e6_ptr = (element*)debug_get_node(sizeof(element));
enqueue(q1, e1_ptr);
enqueue(q1, e2_ptr);
enqueue(q1, e3_ptr);
// append empty queue to non empty queue
append_queue(q1, q3); // destroys q3
TEST_ASSERT_EQUAL(3, get_no_of_elements(q1));
// append non empty queue to empty queue
append_queue(q4, q1); // destroys q1
TEST_ASSERT_EQUAL(3, get_no_of_elements(q4));
enqueue(q5, e4_ptr);
enqueue(q5, e5_ptr);
// append non empty queue to non empty queue
append_queue(q4, q5); // destroys q5
TEST_ASSERT_EQUAL(5, get_no_of_elements(q4));
dequeue(q4);
dequeue(q4);
dequeue(q4);
dequeue(q4);
dequeue(q4);
free_node(e1_ptr);
free_node(e2_ptr);
free_node(e3_ptr);
free_node(e4_ptr);
free_node(e5_ptr);
free_node(e6_ptr);
TEST_ASSERT_EQUAL(0, get_no_of_elements(q4));
// destroy_queue(q1); // destroyed already
// destroy_queue(q2); // destroyed already
// destroy_queue(q3); // destroyed already
destroy_queue(q4);
// destroy_queue(q5); // destroyed already
}
bool
init_http_client() {
debug( "Initializaing HTTP client." );
assert( http_client_thread == NULL );
assert( http_client_efd == -1 );
assert( main_efd == -1 );
assert( transactions == NULL );
http_client_efd = create_event_fd();
assert( http_client_efd >= 0 );
http_client_notify_count = 0;
set_fd_handler( http_client_efd, NULL, NULL, notify_http_client_actually, &http_client_notify_count );
set_writable( http_client_efd, false );
main_efd = create_event_fd();
assert( main_efd >= 0 );
set_fd_handler( main_efd, retrieve_http_transactions_from_http_client, NULL, NULL, NULL );
set_readable( main_efd, true );
assert( main_to_http_client_queue == NULL );
assert( http_client_to_main_queue == NULL );
main_to_http_client_queue = create_queue();
assert( main_to_http_client_queue != NULL );
http_client_to_main_queue = create_queue();
assert( http_client_to_main_queue != NULL );
create_http_transaction_db();
debug( "Initialization completed." );
return true;
}
int main(int argc, char** argv){
static pthread_t thread_serial_id;
static pthread_t thread_flush_serial;
static pthread_t thread_commands;
Queue queue_input;
Queue queue_output;
create_queue(&queue_input);
create_queue(&queue_output);
int fd_;
connect_pty (&fd_);
data_t data = {
.fd = &fd_,
.input = queue_input,
.output = queue_output,
.mutex = PTHREAD_MUTEX_INITIALIZER,
};
int ret = pthread_create(&thread_serial_id, NULL, serial_simulation,
&data);
int ret2 = pthread_create(&thread_flush_serial, NULL, flush_serial,
&data);
int ret3 = pthread_create(&thread_commands, NULL, manage_commands,
&data);
pthread_join (thread_commands, NULL);
pthread_join (thread_serial_id, NULL);
pthread_join (thread_flush_serial, NULL);
return EXIT_SUCCESS;
}
//OpenMP: Given a search string, the function performs a multi-threaded search of the file system starting from the specified path name.
void search_for_string_openmp(char **argv)
{
//What's going on, eh?
printf("OPENMP Execution Started.\n");
// 1 2 3
//<search string> <path> <# of threads>"
//Collect the command line args
char * to_find = argv[1];
char * start_path = argv[2];
unsigned int num_threads = atoi(argv[3]);
unsigned int num_found = 0;
//If there was some way to know where files were located on disk
//To further optimize disk access patterns... that would be neat.
//Ok two queues, one for directories to be searched through
//The other is for filenames themselves
queue_t * dir_queue = create_queue();
queue_t * file_queue = create_queue();
//We don't want queues being locked
//unlocked very often so each thread will pull off a certain number
//of items at a time to look at
unsigned int num_files_per_queue_access = 10;
unsigned int num_dirs_per_queue_access = 1;
//Need to build up a buffer of files in the list before starting
unsigned int file_queue_min_size = 1000;
//So threads will first look to the dir queue to keep finding files
//If no dirs exist then they will look in the file queue for files
//to search through
//Prime the dir queue with the starting directory
place_in_queue(dir_queue, start_path);
//Start the timer
struct timeval start;
gettimeofday(&start, NULL);
//Let's get parallel up in here
#pragma omp parallel num_threads(num_threads) shared(dir_queue, file_queue, num_found) private(num_threads)//num_files_per_queue_access, num_dirs_per_queue_access
{
//Do the search, yo.
omp_grepr(to_find, num_threads, &num_found, dir_queue, file_queue,num_files_per_queue_access,num_dirs_per_queue_access,file_queue_min_size);
}
//Stop timer here and determine the elapsed time
struct timeval stop;
gettimeofday(&stop, NULL);
printf("OPENMP Overall execution time = %fs. \n", (float)(stop.tv_sec - start.tv_sec + (stop.tv_usec - start.tv_usec)/(float)1000000));
printf("OPENMP The string %s was found %d times within the file system. \n\n", to_find , num_found);
}
int main()
{
int pData; //用来保存出队的元素值
//创建队列并进行入队测试
PQUEUE pS1 = create_queue();
PQUEUE pS2 = create_queue();
push(pS1,pS2,4);
push(pS1,pS2,5);
printf("the length of pS1: %d\n",length(pS1));
printf("the length of pS2: %d\n",length(pS2));
if(pop(pS1,pS2,&pData))
printf("%d is pop out\n",pData);
else
printf("Stack is empty,can not pop\n");
printf("the length of pS1: %d\n",length(pS1));
printf("the length of pS2: %d\n",length(pS2));
push(pS1,pS2,6);
printf("the length of pS1: %d\n",length(pS1));
printf("the length of pS2: %d\n",length(pS2));
push(pS1,pS2,7);
printf("the length of pS1: %d\n",length(pS1));
printf("the length of pS2: %d\n",length(pS2));
if(pop(pS1,pS2,&pData))
printf("%d is pop out\n",pData);
else
printf("Stack is empty,can not pop\n");
printf("the length of pS1: %d\n",length(pS1));
printf("the length of pS2: %d\n",length(pS2));
if(pop(pS1,pS2,&pData))
printf("%d is pop out\n",pData);
else
printf("Stack is empty,can not pop\n");
printf("the length of pS1: %d\n",length(pS1));
printf("the length of pS2: %d\n",length(pS2));
if(pop(pS1,pS2,&pData))
printf("%d is pop out\n",pData);
else
printf("Stack is empty,can not pop\n");
printf("the length of pS1: %d\n",length(pS1));
printf("the length of pS2: %d\n",length(pS2));
if(pop(pS1,pS2,&pData))
printf("%d is pop out\n",pData);
else
printf("Stack is empty,can not pop\n");
return 0;
}
void* console_device(void * arg) {
uint32_t scancode;
iorq_t iorq;
int i;
char c;
char * aux;
memset(&keybd_device, 0, sizeof(device_t));
strcpy(keybd_device.ln_link.name, "org.era.dev.console");
keybd_device.iorq_queue = create_queue(10, sizeof(iorq_t));
keybd_queue = create_queue(1, sizeof(uint32_t));
register_interrupt_handler(IRQ1, &keypress_isr);
monitor_writexy(0,24, " 1", 7, 0);
for(;;) {
queue_recv(keybd_device.iorq_queue, &iorq, QM_BLOCKING);
if(iorq.io_desc == DC_READ) {
i = 0;
aux = (char *) iorq.io_dptr;
memset(aux, 0, iorq.io_sz);
while(1) {
queue_recv(keybd_queue, &scancode, QM_BLOCKING);
c = kbdus[scancode];
if (c == '\n')
break;
if ((c == '\b') && (i > 0)) {
aux[i] = '\0';
i--;
monitor_put('\b');
continue;
}
if (c == 0 || c == '\t' || i == (iorq.io_sz - 1))
continue;
if(isprintable(c) ) {
aux[i++] = c;
monitor_put(c);
}
}
monitor_put('\n');
aux[i] = '\0';
queue_send(iorq.io_response, NULL, QM_NONBLOCKING);
}
}
}
/*
* Function: int main(int argc, char args[])
* Description: process main function
* Input: argc: parameter number
* args: parameter value array
* Output: none
* Return: function exit status
* Others: none
*/
int main( )
{
Queue * q;
Ele * ele;
q = create_queue( show_ele, delete_ele );
ele = create_ele( 28, "liwei", 10, "hust++life" );
in_queue( q, ele );
ele = create_ele( 24, "lijia", 10, "hust++acon" );
in_queue( q, ele );
ele = create_ele( 26, "lijing", 10, "hust++acon" );
in_queue( q, ele );
queue_show( q );
printf( "=============\n" );
ele = out_queue( q );
show_ele( ele );
ele = out_queue( q );
show_ele( ele );
ele = out_queue( q );
show_ele( ele );
ele = out_queue( q );
show_ele( ele );
}
int main(){
queue_t *queue;
int i = 0;
int v = 0;
queue = create_queue();
if (queue == NULL){
fprintf(stderr,"Error creating queue\n");
return -EXIT_FAILURE;
}
assert (deq(&v,queue)==0); /*deque an empty queue, print "Queue is empty"*/
for (i = 0; i < 32; ++i)
assert (enq(5,queue)==1); /*fill the queue with 5*/
for (i = 0; i < 32; ++i)
assert (queue->value[i]==5); /*check the entire queue*/
assert (enq(5, queue)==0); /*enque a full queue, print "Queue is full"*/
assert (deq(&v, queue)==1); /*deque the first element*/
assert (enq(6, queue)==1); /*enque 6*/
for (i = 0; i < 32; i++)
assert(deq(&v,queue)==1);
assert (v==6); /*the last element should be 6*/
return EXIT_SUCCESS;
}
int main()
{
int data_de = 0; //用来保存出队的元素值
//创建队列并进行入队测试
PQUEUE pS = create_queue();
en_queue(pS,2);
en_queue(pS,4);
en_queue(pS,6);
traverse_queue(pS);
//出队测试
if(de_queue(pS,&data_de))
printf("delete succeed,the deleted data is: %d\n",data_de);
else
printf("queue is empty! delete falied!\n");
traverse_queue(pS);
//销毁队列测试
destroy_queue(pS);
printf("queue destroyed!\n");
traverse_queue(pS);
return 0;
}
TEST(PRIORITY_QUEUE,FULL){
//try to get the full status of a non existent queue
RESULT result = is_full(424234);
EXPECT_EQ(result.code,TICKET_INVALID);
//fill up the queue
WELCOME_PACKET packet = create_queue();
//if(packet.result.code == SUCCESS){
for(int i = 0; i < MAXIMUM_NUMBER_OF_ELEMENTS_IN_A_QUEUE-1; i++){
ELEMENT e = {i,i%10};
EXPECT_EQ(enqueue(e,packet.ticket).code,SUCCESS);
EXPECT_EQ(is_full(packet.ticket).code,QUEUE_IS_NOT_FULL);
}
ELEMENT e = {3,3};
enqueue(e,packet.ticket);
EXPECT_EQ(is_full(packet.ticket).code,QUEUE_IS_FULL);
enqueue(e,packet.ticket);
EXPECT_EQ(is_full(packet.ticket).code,QUEUE_IS_FULL);
enqueue(e,packet.ticket);
EXPECT_EQ(is_full(packet.ticket).code,QUEUE_IS_FULL);
//delete the queue then try to get the full status
delete_queue(packet.ticket);
EXPECT_EQ(is_full(packet.ticket).code,TICKET_INVALID);
}
/**
* @brief Start new A/V session. There can only be one session at the time. If you register more
* it will result in undefined behaviour.
*
* @param messenger The messenger handle.
* @param userdata The agent handling A/V session (i.e. phone).
* @param video_width Width of video frame.
* @param video_height Height of video frame.
* @return ToxAv*
* @retval NULL On error.
*/
ToxAv *toxav_new( Tox* messenger, ToxAvCodecSettings* codec_settings)
{
ToxAv *av = calloc ( sizeof(ToxAv), 1);
if (av == NULL)
return NULL;
av->messenger = (Messenger *)messenger;
av->msi_session = msi_init_session(av->messenger);
av->msi_session->agent_handler = av;
av->rtp_sessions[0] = av->rtp_sessions [1] = NULL;
/* NOTE: This should be user defined or? */
av->j_buf = create_queue(codec_settings->jbuf_capacity);
av->cs = codec_init_session(codec_settings->audio_bitrate,
codec_settings->audio_frame_duration,
codec_settings->audio_sample_rate,
codec_settings->audio_channels,
codec_settings->video_width,
codec_settings->video_height,
codec_settings->video_bitrate);
return av;
}
/// returns array of distances from source
int* sequential_BFS(int *C, int *R, int v, int src)
{
Queue *q = create_queue(v);
int *dist = (int*)malloc(sizeof(int)*v);
for (int i = 0; i < v; ++i)
{
dist[i] = -1;
}
dist[src] = 0;
enqueue(q, src);
int a, b;
while (!empty(q))
{
a = dequeue(q);
for (int j = R[a]; j < R[a + 1]; ++j)
{
b = C[j];
if (dist[b] == -1)
{
dist[b] = dist[a] + 1;
enqueue(q, b);
}
}
}
return dist;
}
void PriorityQueuetoString(fifo_queue *theArray) {
//fifo_queue *theArray = thePQ->startOfArray;
int i;
for (i = 0; i < NumberOfPriorities; i++ ) {
printf("Q%d:", i);
//FIFOQueuetoString((theArray + i));
fifo_queue *tempqueue = create_queue();
fifo_queue *queue = &theArray[i];
//printf("is_empty %d", is_empty(queue));
//printf("not is_empty %d", !is_empty(queue));
while (!is_empty(queue)) {
//printf("size before dequeue %d", get_size(queue));
PCB_p temp = dequeue(queue);
//toStringShort(temp);
printf("P%d", temp->pid);
enqueue(tempqueue, temp);
if (!is_empty(queue)){
printf("->");
} else {
printf("-");
}
}
printf("*");
//put the data back in the original queue
while (!is_empty(tempqueue)) {
enqueue(queue, dequeue(tempqueue));
}
printf("\n");
}
}
int test_get_elements_queue(){
int value1 = 1;
int value2 = 2;
int value3 = 3;
void *ptr;
Queue *queue = create_queue(sizeof(int));
add(queue, &value1);
add(queue, &value2);
add(queue, &value3);
print_all_elements(queue);
printf("\n-- Removing --\n");
while(1){
ptr = get(queue);
if(ptr != NULL){
printf("removing: %d\n", *((int*)ptr));
}else{
printf("Queue Empty\n");
break;
}
}
free(queue);
return 0;
}
void
test_OneElementQueue(void) {
queue* q = create_queue();
TEST_ASSERT_NOT_NULL(q);
element e = {"string", 3};
element* e_ptr = debug_get_node(sizeof(element));
enqueue(q, e_ptr);
*e_ptr = e;
TEST_ASSERT_FALSE(empty(q));
TEST_ASSERT_NOT_NULL(queue_head(q));
TEST_ASSERT_EQUAL(1, get_no_of_elements(q));
element* e_ptr_returned = dequeue(q);
TEST_ASSERT_NOT_NULL(e_ptr_returned);
TEST_ASSERT_EQUAL_STRING(e_ptr_returned->str, "string");
TEST_ASSERT_EQUAL_PTR(e_ptr_returned, e_ptr);
TEST_ASSERT_EQUAL(0, get_no_of_elements(q));
TEST_ASSERT_TRUE(empty(q));
TEST_ASSERT_NULL(dequeue(q));
destroy_queue(q);
}
//driver code
int main()
{
// Let cache can hold X pages
unsigned int X = 4;
Queue* q = create_queue( X );
// Let Y different pages can be requested (pages to be
// referenced are numbered from 0 to 9
unsigned int Y = 10;
Hash* hash = create_hash( Y );
// Let us refer pages 1, 2, 3, 1, 4, 5
reference_page( q, hash, 1);
reference_page( q, hash, 2);
reference_page( q, hash, 3);
reference_page( q, hash, 1);
reference_page( q, hash, 4);
reference_page( q, hash, 5);
// Let us print cache frames after the above referenced pages
printf ("%d ", q->front->page_no);
printf ("%d ", q->front->next->page_no);
printf ("%d ", q->front->next->next->page_no);
printf ("%d ", q->front->next->next->next->page_no);
return 0;
}
int main()
{
struct priority_queue *queue = create_queue(10);
if (queue == NULL)
printf("create_queue error\n");
insert_queue(queue, 10, (struct huff_table*)10);
insert_queue(queue, 11, (struct huff_table*)11);
insert_queue(queue, 8, (struct huff_table*)8);
insert_queue(queue, 3, (struct huff_table*)3);
insert_queue(queue, 7, (struct huff_table*)7);
insert_queue(queue, 15, (struct huff_table*)15);
uint32_t priority = 0;
struct huff_table *table = NULL;
while (best_queue(queue, &priority, &table)) {
printf("Table = %ld\n", (uint64_t)table);
delete_queue(queue);
}
free_queue(queue);
return EXIT_SUCCESS;
}
void test_empty() {
queue *q = create_queue();
assert(empty(q));
destroy_queue(q);
}
int
main() {
queue_t *q;
item_t t;
int i,j;
q = create_queue(3);
i = 0;
while( fscanf(stdin, "%d", &t) == 1 ) {
if( ! t ) {
if( ! i ) fprintf(stderr, "queue is alread empty\n");
else {
fprintf(stdout, "%d\n", dequeue(q));
i--;
}
} else {
enqueue(q, t);
i++;
}
}
for( j = 0; j < i; j++ ) {
fprintf(stdout, "%d\n", dequeue(q));
}
destroy_queue(q);
return 0;
}
static void BFS(struct graph_s *graph, struct vertex_s *s) {
/* assumes graph is an adjacency list */
int i;
struct listnode_s *adj;
struct vertex_s *u, *v;
struct queue_s *Q;
Q = create_queue(graph->num_vertices);
for (i = 0; i < graph->num_vertices; ++i) {
graph->vertices[i]->color = WHITE;
graph->vertices[i]->distance = 0;
graph->vertices[i]->predecessor = NULL;
}
s->color = GRAY;
enqueue(Q, s);
while (!is_empty(Q)) {
u = dequeue(Q);
for (adj = u->adj; adj; adj = adj->next) {
v = adj->v;
if (v->color == WHITE) {
v->color = GRAY;
v->distance = u->distance+1;
v->predecessor = u;
enqueue(Q, v);
}
}
u->color = BLACK;
}
free(Q->vertices);
free(Q);
}
//Given a queue try to pull some items off
//Let's abuse the things we were given
//Use the queue as a list, order doesn't matter. Why rewrite code;
//Return queue of strings, and the number of items in there
queue_t * get_items(queue_t * queue, unsigned int num_items, unsigned int * num_returned)
{
//Allocate a queue
queue_t * ret_queue = create_queue();
//Remove elements until reaching null or the number requested
*num_returned = 0;
#pragma omp critical
{
while(1)
{
//Try to remove an item
queue_element_t * item = remove_from_queue(queue);
if(item == NULL)
{
break;
}
//Add this item to the queue
insert_in_queue(ret_queue, item);
*num_returned = *num_returned +1;
if(*num_returned >=num_items)
{
break;
}
}
}
//printf("Got %u/%u from queue\n", *num_returned, num_items);
return ret_queue;
}
int main(int argc, char** argv) {
// fifo_queue *q = create_queue();
// PCB pcb = {new, 0, 0, 0, 0, 0};
// enqueue(q, &pcb);
// PCB pcb2 = {new, 0, 0, 0, 0, 0};
// enqueue(q, &pcb2);
// printf("Hello");
// pcb.next_pcb = &pcb2;
// toString(&pcb);
fifo_queue *queue = create_queue();
PCB pcb = {new, 1, 23, 0, 23, 23, 23, 4, 5};
PCB pcb2 = {new, 2, 34, 0, 34, 34, 34, 2, 1};
enqueue(queue, &pcb);
to_string_enqueue(queue);
enqueue(queue, &pcb2);
to_string_enqueue(queue);
PCB_p pcb_removed = dequeue(queue);
to_string_dequeue(queue, pcb_removed);
pcb_removed = dequeue(queue);
to_string_dequeue(queue, pcb_removed);
testPQ();
// pcb.next_pcb = &pcb2;
// toString(&pcb);
// toString(&pcb2);
return (EXIT_SUCCESS);
}
/*
******************************************************************************
* dgadmin_rest_sync_main -- *//**
*
* \brief This routine periodically starts sync circle.
*
* \param [in] pDummy Not used.
*
* \retval None
*
*****************************************************************************/
static void dgadmin_rest_sync_main(UINT1 *pDummy)
{
unsigned int listenEvent = 0;
unsigned int recvEvent = 0;
if (sem_give(gDgwySyncSemId) != OSW_OK)
{
return;
}
if (create_queue("RSYNC", OSW_MAX_Q_MSG_LEN, 10, &gDgwySyncMsgId) != OSW_OK)
{
printf("%s:error when create queue\n",__FUNCTION__);
return;
}
if (create_timer("RSTASK", DGWY_SYNC_TASK_TIMER_EVENT,
NULL, 0, &gDgwySyncTimerListId) != OSW_OK)
{
printf("%s:error when create_timer\n",__FUNCTION__);
return;
}
/* start the timer */
start_timer(gDgwySyncTimerListId, DGADMIN_REST_SYNC_INTERVAL, 0);
listenEvent = DGWY_SYNC_TASK_TIMER_EVENT;/* | DGWY_SYNC_TASK_MSG_EVENT; */
log_info(ServiceUtilLogLevel,
"INIT REST SYNC TASK ");
while (1)
{
if(recv_event(gDgwySyncTaskId, listenEvent, OSW_NO_WAIT, &recvEvent) == OSW_ERROR)
{
sleep(10);
continue;
}
log_debug(ServiceUtilLogLevel,"recvEvent %d\n",
recvEvent);
if(recvEvent & DGWY_SYNC_TASK_TIMER_EVENT)
{
if(g_dgw_role)
{
/* Try to be in sync with DMC */
log_notice(ServiceUtilLogLevel,
"SYNC START: version %d\n",
g_dgwconfig_curversion);
dgadmin_rest_sync_process();
log_notice(ServiceUtilLogLevel,
"SYNC END : version %d\n",
g_dgwconfig_curversion);
}
start_timer(gDgwySyncTimerListId, DGADMIN_REST_SYNC_INTERVAL, 0);
}
}
}
void test_isEmpty_full(){
int value1 = 1;
Queue *queue = create_queue(sizeof(int));
add(queue, &value1);
if(!isEmpty(queue))
printf("Success - fila not empty\n");
free(queue);
}
int main()
{
Queue *q = create_queue(20);
Argument *arg = create_argument(q,10);
create_threads((void *)arg);
printf("Complete\n");
return(0);
}
static void *
capture_main( void *args ) {
UNUSED( args );
info( "Starting packet capture ( interface_name = %s ).", interface_name );
packet_queue = create_queue();
pcap_t *cd = NULL;
if ( packet_queue == NULL ) {
error( "Failed to create packet queue." );
goto error;
}
char errbuf[ PCAP_ERRBUF_SIZE ];
bpf_u_int32 mask = 0;
bpf_u_int32 net = 0;
int ret = pcap_lookupnet( interface_name, &net, &mask, errbuf );
if ( ret < 0 ) {
error( "Failed to get netmask for device %s ( error = %s ).", interface_name, errbuf );
net = 0;
mask = 0;
}
cd = pcap_open_live( interface_name, UINT16_MAX, 1, 100, errbuf );
if ( cd == NULL ) {
error( "Failed to open network interface ( interface_name = %s, error = %s ).",
interface_name, errbuf );
goto error;
}
if ( filter_expression != NULL ) {
struct bpf_program fp;
ret = pcap_compile( cd, &fp, filter_expression, 0, net );
if ( ret < 0 ) {
error( "Failed to parse filter `%s' ( error = %s ).", filter_expression, pcap_geterr( cd ) );
goto error;
}
ret = pcap_setfilter( cd, &fp );
if ( ret < 0 ) {
error( "Failed to set filter `%s' ( error = %s ).", filter_expression, pcap_geterr( cd ) );
goto error;
}
}
int dlt = pcap_datalink( cd );
pcap_loop( cd, -1, handle_packet, ( u_char * ) &dlt );
error:
if ( cd != NULL ) {
pcap_close( cd );
}
if ( packet_queue != NULL ) {
delete_queue( packet_queue );
}
return NULL;
}
//struct thread_pool* tp_init_thread_pool(struct thread_pool* pool, int numthr, void*(func)(void*), char* name )
struct thread_pool *tp_create_thread_pool(int numthr, void *(func) (void *), char *name)
{
struct thread_pool *pool;
int i;
if (numthr > MAX_THREAD_NUM) {
printf("Error!! numthr %d > MAX-THREAD-NUM\n", numthr);
return NULL;
}
/// alloc a thread-pool
pool = (struct thread_pool *) malloc(sizeof(struct thread_pool));
if (!pool) {
printf("Fail to create thrpool %s\n", name);
return NULL;
}
memset(pool, 0, sizeof(struct thread_pool));
// set thread-pool name
strncpy(pool->name, name, 15);
pool->name[15] = 0;
pool->num_threads = numthr;
// work-queue associated with thread-pool
pool->queue = create_queue("RR-queue");
if (pool->queue == NULL) {
error("Fail to create queue\n");
goto err_out_1;
}
dump_queue(pool->queue);
/// the mutex and bitmap is not necessary now...
pthread_mutex_init(&pool->mutex, NULL);
/// now bitmap is no longer needed in a thread-pool, replaced by a work-queue
bmp_init(&pool->bitmap, numthr, 1); // initially all bits are "1": free
//bmp_dump( &pool->bitmap);
/// create the thread-pool
for (i = 0; i < numthr; i++) {
//sem_init( &pool->sem[i], 0, 0); // init the sem-count to be 0
//pool->arg1[i] = 0;
//pool->arg2[i] = 0;
if (pthread_create(&pool->thread[i], NULL, func, (void *) pool) != 0) {
error("Error creating thread %d in pool %s\n", i, name);
}
}
//dbg("tpool %s: init bitmap= %s\n", pool->name, int_to_binary(pool->bitmap) );
printf("Have created tpool %s: thr-num = %d\n", pool->name, pool->num_threads);
return pool;
err_out_1:
tp_destroy_thread_pool(pool);
return NULL;
}
int main (int argc, char **argv)
{
if ( argc != 2){
printf ("usage: %s number_of_details\n", argv[0]);
return 2;
}
// получаем очередь сообщений для всех процессов.
create_queue();
/* создаем процесс - закрутчик гаек. */
create_nipple_worker( 0);
create_nipple_worker( 1);
/* создаем процесс - закрутчик винтов. */
create_screw_worker( 2);
message mbuf;
// cnt раз подадим деталь на тиски.
int cnt = atoi (argv[1]);
printf (" %d details\n", cnt);
do{
//сообщим всем процессам - что деталь установлена.
//(поместим _три_ сообщения в очередь)
int i;
printf("send new detail, last #%d\n", cnt-1);
for( i = 0; i < NUM_OF_WORKERS; i++){
message mbuf;
mbuf.mtype = NEW_DETAIL_FOR_1 + i;
//new_detail_for_1
//new_detail_for_2
//new_detail_for_3 =)
if ( msgsnd ( msqid, &mbuf, 2, IPC_NOWAIT) < 0){
perror ("msgsnd");
return 1;
}
}
// Проверим, все-ли закончили свою работу?
if ( msgrcv (msqid, &mbuf, 2, ONE_NIPPLE_INSTALLED, 0) < 0 ){
perror ("msgrcv");
return 1;
}
if ( msgrcv (msqid, &mbuf, 2, ONE_NIPPLE_INSTALLED, 0) < 0 ){
perror ("msgrcv");
return 1;
}
if ( msgrcv (msqid, &mbuf, 2, ONE_SCREW_INSTALLED, 0) < 0 ){
perror ("msgrcv");
return 1;
}
} while (--cnt > 0);
//удаляем очередь
if ( msgctl (msqid, IPC_RMID, NULL) < 0 ){
perror ("queue delete:");
return 1;
}
printf("finished\n");
return 0;
}
priority_queue_p create_priority_queue() {
int i;
priority_queue_p pq = malloc(sizeof(fifo_queue_p) * NumberOfPriorities);
for (i = 0; i < NumberOfPriorities; i++) {
pq->MainArray[i] = create_queue();
}
pq->size = 0;
return pq;
}
/**
* @brief Must be call before any RTP transmission occurs.
*
* @param av Handler.
* @return int
* @retval 0 Success.
* @retval ToxAvError On error.
*/
int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, ToxAvCodecSettings *codec_settings, int support_video )
{
if ( !av->msi_session || av->msi_session->max_calls <= call_index || !av->msi_session->calls[call_index] ) {
/*fprintf(stderr, "Error while starting audio RTP session: invalid call!\n");*/
return ErrorInternal;
}
CallSpecific *call = &av->calls[call_index];
call->crtps[audio_index] =
rtp_init_session(
type_audio,
av->messenger,
av->msi_session->calls[call_index]->peers[0],
av->msi_session->calls[call_index]->key_peer,
av->msi_session->calls[call_index]->key_local,
av->msi_session->calls[call_index]->nonce_peer,
av->msi_session->calls[call_index]->nonce_local);
if ( !call->crtps[audio_index] ) {
/*fprintf(stderr, "Error while starting audio RTP session!\n");*/
return ErrorStartingAudioRtp;
}
if ( support_video ) {
call->crtps[video_index] =
rtp_init_session (
type_video,
av->messenger,
av->msi_session->calls[call_index]->peers[0],
av->msi_session->calls[call_index]->key_peer,
av->msi_session->calls[call_index]->key_local,
av->msi_session->calls[call_index]->nonce_peer,
av->msi_session->calls[call_index]->nonce_local);
if ( !call->crtps[video_index] ) {
/*fprintf(stderr, "Error while starting video RTP session!\n");*/
return ErrorStartingVideoRtp;
}
}
if ( !(call->j_buf = create_queue(codec_settings->jbuf_capacity)) ) return ErrorInternal;
call->cs = codec_init_session(codec_settings->audio_bitrate,
codec_settings->audio_frame_duration,
codec_settings->audio_sample_rate,
codec_settings->audio_channels,
codec_settings->video_width,
codec_settings->video_height,
codec_settings->video_bitrate);
return call->cs ? ErrorNone : ErrorInternal;
}
