Пример #1
0
void *event_listener_loop(void *arg) {
    int sock;
    struct sockaddr_in server;
    char str_random_port[30];
    pthread_t vlc_thread;
    Blackadder *ba = (Blackadder *) arg;
    /*create a random port*/
    int random_port = (rand() % 10000 + 3000);
    snprintf(str_random_port, sizeof (str_random_port), "%d", random_port);
    pthread_create(&vlc_thread, NULL, vlc_thread_loop, str_random_port);

    /*create the UDP loopback sender*/
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    server.sin_port = htons(random_port);
    sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        perror("socket");
    }
    while (true) {
        Event ev;
        ba->getEvent(ev);
        if (ev.type == PUBLISHED_DATA) {
            sendto(sock, ev.data, ev.data_len, 0, (struct sockaddr *) &server, sizeof (server));
        } else {
            cout << "weird" << endl;
        }
    }
}
Пример #2
0
void *event_listener_loop(void *arg) {
    Blackadder *ba = (Blackadder *) arg;
    while (true) {
        Event ev;
        ba->getEvent(ev);
        if (ev.type == PUBLISHED_DATA) {
            //cout << "TM: received a request...processing now" << endl;
            handleRequest((char *) ev.data, ev.data_len);
        } else {
            cout << "TM: I am not expecting any other notification...FATAL" << endl;
        }
    }
}
Пример #3
0
void *event_listener_loop(void *arg) {
    Blackadder *ba = (Blackadder *) arg;
    while (true) {
        Event ev = ba->getEvent();
        if (ev.type == PUBLISHED_DATA) {
            //cout<<"received data of size: "<< ev.data_len << endl;
            if (ev.data[0] == 'A') {
                if (experiment_started == false) {
                    experiment_started = true;
                    gettimeofday(&start_tv, &tz);
                    printf("START TIME: %ld,%ld \n", start_tv.tv_sec, start_tv.tv_usec);
                }
                //cout << "received published data for ID " << chararray_to_hex(str_id) << "!! size: " << (total_buf_size - (sizeof (struct nlmsghdr) + sizeof (unsigned char) + sizeof (unsigned char) +str_id.size())) << endl;
                counter++;
            }
            if (ev.data[0] == 'B') {
                //printf("Received %d packets\n", counter);
                gettimeofday(&end_tv, &tz);
                //printf("END TIME: %ld,%ld \n", end_tv.tv_sec, end_tv.tv_usec);
                duration.tv_sec = end_tv.tv_sec - start_tv.tv_sec;
                if (end_tv.tv_usec - start_tv.tv_usec > 0) {
                    duration.tv_usec = end_tv.tv_usec - start_tv.tv_usec;
                } else {
                    duration.tv_usec = end_tv.tv_usec + 1000000 - start_tv.tv_usec;
                    duration.tv_sec--;
                }
                printf("duration: %ld seconds and %d microseconds\n\n", duration.tv_sec, duration.tv_usec);
                float left = counter * ((float) payload_size / (float) (1024 * 1024));
                float right = ((float) ((duration.tv_sec * 1000000) + duration.tv_usec)) / 1000000;

                cout << "counter: " << counter << endl;
                cout << "payload_size: " << payload_size << endl;
                //cout << "left: " << left << endl;
                //cout << "right: " << right << endl;

                float throughput = (left / right);

                printf("Throughput: %f MB/sec \n\n", throughput);
                break;
            }
        }
    }
}
Пример #4
0
void *event_listener_loop(void *arg) {
    Blackadder *ba = (Blackadder *) arg;
    Event ev;
    int i;
    ba->getEvent(ev);
    if (ev.type == START_PUBLISH) {
        cout << "start publishing " << endl;
        gettimeofday(&start_tv, &tz);
        for (i = 0; i < 1000000; i++) {
            //cout << "publishing data for ID " << chararray_to_hex(ev.id) << endl;
            ba->publish_data(ev.id, DOMAIN_LOCAL, NULL, 0, payload, payload_size);
        }
        gettimeofday(&end_tv, &tz);
        for (int j = 0; j < 1000; j++) {
            //cout << "publishing end flag for ID " << chararray_to_hex(ev.id) << endl;
            ba->publish_data(ev.id, DOMAIN_LOCAL, NULL, 0, end_payload, payload_size);
        }
    }
    duration.tv_sec = end_tv.tv_sec - start_tv.tv_sec;
    if (end_tv.tv_usec - start_tv.tv_usec > 0) {
        duration.tv_usec = end_tv.tv_usec - start_tv.tv_usec;
    } else {
        duration.tv_usec = end_tv.tv_usec + 1000000 - start_tv.tv_usec;
        duration.tv_sec--;
    }
    printf("duration: %ld seconds and %ld microseconds\n\n", duration.tv_sec, duration.tv_usec);
    int counter = i;
    float left = counter * ((float) payload_size / (float) (1024 * 1024));
    float right = ((float) ((duration.tv_sec * 1000000) + duration.tv_usec)) / 1000000;
    cout << "counter: " << counter << endl;
    cout << "payload_size: " << payload_size << endl;
    float throughput = (left / right);
    printf("Throughput: %f MB/sec \n", throughput);
    float pps = ((float) counter) / right;
    printf("%f pps\n\n", pps);
    return NULL;
}
Пример #5
0
void *event_listener_loop(void *arg) {
    int bug_counter = 0;
    Blackadder *ba = (Blackadder *) arg;
    string bin_prefix_id = string();
    string hex_id = string();
    string bin_backchannel_id = string();
    while (true) {
        Event ev = ba->getEvent();
        hex_id = chararray_to_hex(ev.id);
        switch (ev.type) {
            case SCOPE_PUBLISHED:
                //cout << "SCOPE_PUBLISHED: " << hex_id << endl;
                break;
            case SCOPE_UNPUBLISHED:
                //cout << "SCOPE_UNPUBLISHED: " << hex_id << endl;
                break;
            case START_PUBLISH:
                //cout << "START_PUBLISH: " << hex_id << endl;
                bin_backchannel_id = hex_to_chararray(backchannel_id);
                if (hex_id.compare("00000000000000002222222222222222" + backchannel_id) == 0) {
                    char *hello = (char *) malloc(sizeof ("hello"));
                    memcpy(hello, "hello", sizeof ("hello"));
                    ba->publish_data(ev.id, DOMAIN_LOCAL, NULL, hello, sizeof ("hello"));
                    cout << hex_id << " will be used as the backchannel to the publisher" << endl;
                }
                break;
            case STOP_PUBLISH:
                cout << "STOP_PUBLISH: " << hex_id << endl;
                break;
            case PUBLISHED_DATA:
                //cout << "PUBLISHED_DATA: " << hex_id << endl;
                //cerr<<"lock!!!"<<endl;
                if (ev.id.compare(full_info_id) == 0) {
                    /*start measuring*/
                    gettimeofday(&start_tv, &tz);
                    printf("START TIME: %ld,%ld \n", start_tv.tv_sec, start_tv.tv_usec);
                    /*that's the metadata*/
                    efs = new ExpectedFragmentSequence();
                    memcpy(&global_number_of_fragments, ev.data, sizeof (global_number_of_fragments));

                    /*the bandwidth would be useful to calculate that as well :)*/
                    retransmission_threshold = global_number_of_fragments / 1;

                    /*set up the required state for defragmentation*/
                    efs->number_of_fragments = global_number_of_fragments;
                    efs->fragments_so_far = 0;
                    string zero_id = hex_to_chararray("0000000000000000");
                    efs->expected_fragment = ev.id + zero_id;
                    efs->first_fragment = ev.id + zero_id;
                    efs->last_fragment = efs->first_fragment;
                    calculate_fragment_from_int(efs->last_fragment, global_number_of_fragments);
                    efs->expected_fragment_offset = 0;
                    efs->fragments_map = Bitvector(global_number_of_fragments);
                    efs->time_beat = 10;
                    /*advertised the item /0000000000000000/ALGID(1111111111111111)/alg(ID,myself)
                     * (for now, ALGID(1111111111111111)=2222222222222222 and alg(ID,myself)=3333333333333333) to create the back channel to the publisher*/
                    string prefix_id = "00000000000000003333333333333333";
                    backchannel_id = string();
                    create_random_ID(backchannel_id); /*in hex*/
                    efs->p_to_s_channel = hex_to_chararray(prefix_id + backchannel_id);
                    bin_prefix_id = hex_to_chararray(prefix_id);
                    bin_backchannel_id = hex_to_chararray(backchannel_id);
                    ba->subscribe_info(bin_backchannel_id, bin_prefix_id, DOMAIN_LOCAL, NULL);
                    prefix_id = "00000000000000002222222222222222";
                    efs->s_to_p_channel = hex_to_chararray(prefix_id + backchannel_id);
                    bin_prefix_id = hex_to_chararray(prefix_id);
                    bin_backchannel_id = hex_to_chararray(backchannel_id);
                    ba->publish_info(bin_backchannel_id, bin_prefix_id, DOMAIN_LOCAL, NULL);
                    efs->printEFS();
                    pthread_create(&timeout_thread, NULL, timeout_handler, (void *) ba);
                } else {
                    pthread_mutex_lock(&global_mutex);
                    if (efs != NULL) {
                        efs->time_beat = 10;
                        if (ev.id.substr(0, 2 * PURSUIT_ID_LEN).compare(full_info_id) == 0) {
                            //cout << "an in-band transmission: " << chararray_to_hex(ev.id) << endl;
                            if (ev.id.compare(efs->expected_fragment) == 0) {
                                //cout << "expected" << chararray_to_hex(ev.id) << endl;
                                find_next(efs->expected_fragment);
                                efs->fragments_so_far++;
                                efs->fragments_map[efs->expected_fragment_offset] = true;
                                //cout << "setting bit " << (efs->expected_fragment_offset) << endl;
                                //cout << efs->fragments_map.to_string().c_str() << endl;
                                efs->expected_fragment_offset++;
                                if (efs->fragments_so_far == efs->number_of_fragments) {
                                    pthread_cancel(timeout_thread);
                                    delete efs;
                                    efs = NULL;
                                    printResult();
                                    break;
                                }
                            } else {
                                //cout << "NOT expected" << endl;
                                int distance = calculate_number_of_fragments(efs->expected_fragment, ev.id) - 1; //e.g. from 0 to 1 distance = 1
                                if (distance == -1) {
                                    cout << chararray_to_hex(ev.id) << " is a duplicate " << endl;
                                } else if (Bitvector::Bit::unspecified_bool_type(efs->fragments_map[efs->expected_fragment_offset + distance]) != false) {
                                    cout << chararray_to_hex(ev.id) << " is a duplicate! " << endl;
                                } else {
                                    efs->fragments_so_far++;
                                    efs->fragments_map[efs->expected_fragment_offset + distance] = true;
                                    //cout << "setting bit " << (efs->expected_fragment_offset + distance) << endl;
                                    //cout << efs->fragments_map.to_string().c_str() << endl;
                                }
                                if (efs->fragments_so_far == efs->number_of_fragments) {
                                    pthread_cancel(timeout_thread);
                                    delete efs;
                                    efs = NULL;
                                    printResult();
                                    break;
                                }
                            }
                        } else {
                            string mapped_id = root_scope + info_id + ev.id.substr(ev.id.length() - PURSUIT_ID_LEN, PURSUIT_ID_LEN);
                            //cout << "a retransmission: " << chararray_to_hex(mapped_id) << endl;
                            if (mapped_id.compare(efs->expected_fragment) == 0) {
                                //cout << "expected" << endl;
                                efs->fragments_so_far++;
                                efs->fragments_map[efs->expected_fragment_offset] = true;
                                if (efs->fragments_so_far == efs->number_of_fragments) {
                                    pthread_cancel(timeout_thread);
                                    delete efs;
                                    efs = NULL;
                                    printResult();
                                    break;
                                }
                                if (Bitvector::Bit::unspecified_bool_type(efs->fragments_map[efs->expected_fragment_offset + 1]) == false) {
                                    find_next(efs->expected_fragment);
                                    //cout << "setting bit " << (efs->expected_fragment_offset) << endl;
                                    //cout << efs->fragments_map.to_string().c_str() << endl;
                                    efs->expected_fragment_offset++;
                                } else {
                                    //cout << "the next fragment is already received so I have to move to the new expected" << endl;
                                    //cout << "setting bit " << (efs->expected_fragment_offset) << endl;
                                    //cout << efs->fragments_map.to_string().c_str() << endl;
                                    find_next(efs->expected_fragment);
                                    efs->expected_fragment_offset++;
                                    while ((Bitvector::Bit::unspecified_bool_type(efs->fragments_map[efs->expected_fragment_offset]) != false) && (efs->expected_fragment_offset < efs->fragments_map.size())) {
                                        find_next(efs->expected_fragment);
                                        efs->expected_fragment_offset++;
                                    }
                                    //cout << "now I am expecting " << chararray_to_hex(efs->expected_fragment) << endl;
                                    //cout << "now I am expecting " << efs->expected_fragment_offset << endl;
                                }
                            } else {
                                //cout << "NOT expected" << endl;
                                int distance = calculate_number_of_fragments(efs->expected_fragment, mapped_id) - 1; //e.g. from 0 to 1 distance = 1
                                if (distance == -1) {
                                    cout << chararray_to_hex(mapped_id) << " was a duplicate!!" << endl;
                                } else if (Bitvector::Bit::unspecified_bool_type(efs->fragments_map[efs->expected_fragment_offset + distance]) != false) {
                                    //cout << chararray_to_hex(mapped_id) << " is a duplicate!!! " << endl;
                                } else {
                                    efs->fragments_so_far++;
                                    efs->fragments_map[efs->expected_fragment_offset + distance] = true;
                                    //cout << "setting bit " << (efs->expected_fragment_offset + distance) << endl;
                                    //cout << efs->fragments_map.to_string().c_str() << endl;
                                    if (efs->fragments_so_far == efs->number_of_fragments) {
                                        pthread_cancel(timeout_thread);
                                        delete efs;
                                        efs = NULL;
                                        printResult();
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    pthread_mutex_unlock(&global_mutex);
                }
                break;
        }
    }
}
Пример #6
0
void *timeout_handler(void *arg) {
    Blackadder *ba = (Blackadder *) arg;
    while (true) {
        int retr_thres_counter = 0;
        pthread_mutex_lock(&global_mutex);
        if (efs == NULL) {
            cout << "NO EFS - NULL - NADA" << endl;
            break;
        }
        string temp_id = efs->expected_fragment;
        efs->time_beat--;
        if (efs->time_beat == 0) {
            cout << "timeout" << endl;
            /*find all non received fragments and send multiple requests for sequences of fragments*/
            int i = efs->expected_fragment_offset;
            //cout << "efs->expected_fragment_offset: " << efs->expected_fragment_offset << endl;
            while (i < efs->fragments_map.size()) {
                int temp_offset = 0;
                int required_fragments = 0;
                while ((Bitvector::Bit::unspecified_bool_type(efs->fragments_map[i]) == false) && (i < efs->fragments_map.size())) {
                    required_fragments++;
                    i++;
                    temp_offset++;
                    retr_thres_counter++;
                }
                pthread_mutex_unlock(&global_mutex);
                string test = temp_id;
                calculate_fragment_from_int(test, required_fragments);
                //cout << "request retransmission " << chararray_to_hex(temp_id) << " to  " << chararray_to_hex(test) << "  " << required_fragments << endl;
                unsigned char IDlen = temp_id.length() / PURSUIT_ID_LEN;
                char *retransmission_payload = (char *) malloc(sizeof (IDlen) + temp_id.length() + sizeof (required_fragments) + sizeof (sequence_number));
                memcpy(retransmission_payload, &IDlen, sizeof (IDlen));
                memcpy(retransmission_payload + sizeof (IDlen), temp_id.c_str(), temp_id.length());
                memcpy(retransmission_payload + sizeof (IDlen) + temp_id.length(), &required_fragments, sizeof (required_fragments));
                memcpy(retransmission_payload + sizeof (IDlen) + temp_id.length() + sizeof (required_fragments), &sequence_number, sizeof (sequence_number));
                ba->publish_data(efs->s_to_p_channel, DOMAIN_LOCAL, NULL, retransmission_payload, sizeof (IDlen) + temp_id.length() + sizeof (required_fragments) + sizeof (sequence_number));
                sequence_number++;
                free(retransmission_payload);
                if (retr_thres_counter > retransmission_threshold) {
                    //cout << "breaking because of threshold " << retransmission_threshold << endl;
                    break;
                }

                calculate_fragment_from_int(temp_id, temp_offset);
                find_next(temp_id);
                pthread_mutex_lock(&global_mutex);

                while ((Bitvector::Bit::unspecified_bool_type(efs->fragments_map[i]) != false) && (i < efs->fragments_map.size())) {
                    //cout << chararray_to_hex(temp_id) << "  is set" << endl;
                    find_next(temp_id);
                    i++;
                    temp_offset++;
                }
                temp_offset = temp_offset++;
            }
            efs->time_beat = 10;
        } else if (efs->time_beat < 0) {
            cout << "that should not happen" << endl;
        }

        pthread_mutex_unlock(&global_mutex);
        usleep(20000);

        //cout << "end of timeout!" << endl;
    }
}