void *producer_function(void *b)
{
buffer *buff = (buffer *)b;
int i;
for (i = 0; i < 100; i++)
{
pthread_mutex_lock(buff->mut);
if(buff->full)
{
printf("buffer full, waiting...\n");
pthread_cond_wait(buff->notFull, buff->mut);
}
int random = generate_random_number(RANDOM_NUMBER_UPPER_LIMIT);
buffer_add(buff, random);
printf("produced %d\n", random);
pthread_mutex_unlock(buff->mut);
/* Sleep either 1s or 4s (50% chance for each) */
if (generate_random_number(99) < 50)
{
usleep(1000000);
}
else
{
usleep(4000000);
}
}
return NULL;
}
void Terrain::generate_rocks( void )
{
std::pair<unsigned short , unsigned short> temp;
for( auto i = 0; i < rocks; ++i )
{
temp.first = generate_random_number( min_rock_width , max_rock_width );
temp.second = generate_random_number( min_rock_height , max_rock_height );
rock_info.push_back( temp );
}
}
void *consumer_function(void *b)
{
buffer *buff = (buffer *)b;
int i;
for (i = 0; i < 100; i++)
{
pthread_mutex_lock(buff->mut);
if(buff->empty)
{
printf("buffer empty, waiting...\n");
pthread_cond_wait(buff->notEmpty, buff->mut);
}
int consumed = buffer_consume(buff);
printf("consumed %d\n", consumed);
pthread_mutex_unlock(buff->mut);
/* Sleep either 1s or 5s (50% chance for each) */
if (generate_random_number(99) < 50)
{
usleep(1000000);
}
else
{
usleep(5000000);
}
}
return NULL;
}
static const char *
rdv_randompath(void) {
uint64_t r = generate_random_number();
/* Looks like flickr for now */
return (aprintf("photos/26907150@N08/%" PRIu64 "/lightbox", r));
}
/**
* Método usado para gerar a lista de inteiros que serão utilizados para
* serem colocados nos respectivos BINs. O números são gerados de forma
* aleatória. IMPORTANTE: A média global entre eles deve ser igual ou
* superior a 20.
*
* \param values Ponteiro para o array onde foram inseridos os números para
* serem empacotados
* \see generate_random_number
* \see NUMBERS_QUANTITY
* \see NUMBERS_MINIMUM
* \see NUMBERS_MAXIMUM
*/
int create_numbers_array (unsigned short int *values)
{
unsigned short int i;
for (i = 0; i < NUMBERS_QUANTITY; i++)
{
/** Os elementos da lista devem ter valores entre a media desejada e o espaço disponivel nos BINs */
values[i] = generate_random_number(NUMBERS_MINIMUM , NUMBERS_MAXIMUM);
}
return 0;
}
void construct_second_level(struct cell **arr,struct collision_keys **b,int b_size)
{
struct cell **second_level_table=NULL;
long long int i,j,num,c,loc;
long long int n,r,sum=0;
int nr,cr;
for(i=0;i<MAX;i++)
{
if(arr[i]->collision>0)
{
n=(arr[i]->collision)*(arr[i]->collision);
for(j=0;j<n;j++)
{
second_level_table[j]=(struct cell*)malloc(sizeof(struct cell));
second_level_table[j]->next_level=NULL;
second_level_table[j]->key=-1;
second_level_table[j]->random_no=0;
second_level_table[j]->collision=0;
}
arr[i]->next_level=second_level_table[0];
}
}
for(i=0;i<b_size;i++)
{
num=b[i]->key;
c=generate_random_number(num);
n=num;
r=c;
while(n>0||c>0)
{
nr=n%10;
cr=r%10;
n=n/10;
r=r/10;
sum=sum+nr*cr;
}
loc=sum;
sum=0;
if((arr[b[i]->index]->next_level)[loc].key!=-1)
{
((arr[b[i]->index]->next_level)[loc].collision)++;
}
else
{
(arr[b[i]->index]->next_level)[loc].key=b[i]->key;
}
printf("\nh=%d\n",(arr[b[i]->index]->next_level)[loc].collision);
}
//printf("\nHey\n");
}
int extract_input(char *file_name,struct cell**a,struct collision_keys **c_key)
{
int r,nr,cr;
long long int index,num=0,i,c,sum=0,rand,n,k=0,x;
FILE *f;
char* line;
ssize_t len=0;
ssize_t read;
f=fopen(file_name,"r");
if(f)
{ while((read=getline(&line,&len,f))!=-1)
{
i=0;
while((int)line[i]!=10)
{
while((int)line[i]!=44&&(int)line[i]!=10)
{
if((int)line[i]==32)
{
i++; //spaces removed
}
else
{
r=(int)line[i]-48;
num=num*10+r;
i++;
}
}
x=MAX;
c=generate_random_number(x);
rand=c;
n=num;
while(rand>0||n>0)
{
cr=rand%10;
nr=n%10;
rand=rand/10;
n=n/10;
sum=sum+nr*cr;
}
index=sum%MAX;
if(a[index]->key!=-1)
{
(a[index]->collision)++;
c_key[k]=(struct collision_keys*)malloc(sizeof(struct collision_keys));
c_key[k]->key=num;
c_key[k]->index=index;
k++;
}
else
{
a[index]->key=num;
a[index]->random_no=c;
}
num=0;
sum=0;
if((int)line[i]!=10) //if it is not the last number in the line
i++;
}
}
}
printf("\nk=%lld\n",k);
return k;
}
// 정해진 정렬을 수행하고 수행 시간을 리턴해주는 함수
float do_sort(int sort_code, int* randomNum, int* bCheckExistOfNum, int number){
time_t startTime,endTime; // 함수 수행 시작시간, 종료시간
int i;
float gap; // 총 함수 수행시간
switch(sort_code){ // 정렬 코드에 따라서 다른 정렬을 수행한다
//삽입 정렬의 경우
case 1:
printf("난수 %d개를 생성 중입니다...\n", number);
Sleep(3000);
generate_random_number(randomNum, bCheckExistOfNum, number);
printf("\n난수가 %d개 생성되었습니다.\n", number);
Sleep(3000);
printf("정렬 알고리즘을 시작합니다..\n");
startTime = clock();
insertSort(randomNum, number);
endTime = clock();
printf("정렬 알고리즘이 완료되었습니다.\n");
gap=(float)(endTime-startTime)/(CLOCKS_PER_SEC); //계산
printf("총 수행 시간 : %f초\n", gap);
Sleep(3000);
printf("정렬된 결과를 출력합니다.\n");
Sleep(3000);
for(i = 0 ; i < number ; i++){
printf("%d ", randomNum[i]);
}
printf("\n정렬이 완료되었습니다.\n");
Sleep(3000);
return gap;
// 선택 정렬의 경우
case 2:
printf("난수 %d개를 생성 중입니다...\n", number);
Sleep(3000);
generate_random_number(randomNum, bCheckExistOfNum, number);
printf("\n난수가 %d개 생성되었습니다.\n", number);
Sleep(3000);
printf("정렬 알고리즘을 시작합니다..\n");
startTime = clock();
selectionSort(randomNum, number); // 선택 정렬 실행.
endTime = clock();
printf("정렬 알고리즘이 완료되었습니다.\n");
gap=(float)(endTime-startTime)/(CLOCKS_PER_SEC); //계산
printf("총 수행 시간 : %f초\n", gap);
Sleep(3000);
printf("정렬된 결과를 출력합니다.\n");
Sleep(3000);
for(i = 0 ; i < number ; i++){
printf("%d ", randomNum[i]);
}
printf("\n정렬이 완료되었습니다.\n");
Sleep(3000);
return gap;
// 합병 정렬의 경우
case 3:
printf("난수 %d개를 생성 중입니다...\n", number);
Sleep(3000);
generate_random_number(randomNum, bCheckExistOfNum, number);
printf("\n난수가 %d개 생성되었습니다.\n", number);
Sleep(3000);
printf("정렬 알고리즘을 시작합니다..\n");
startTime = clock();
mergeSort(randomNum, 0, number); // 합병 정렬 실행.
endTime = clock();
printf("정렬 알고리즘이 완료되었습니다.\n");
gap=(float)(endTime-startTime)/(CLOCKS_PER_SEC); //계산
printf("총 수행 시간 : %f초\n", gap);
Sleep(3000);
printf("정렬된 결과를 출력합니다.\n");
Sleep(3000);
for(i = 0 ; i < number ; i++){
printf("%d ", randomNum[i]);
}
printf("\n정렬이 완료되었습니다.\n");
Sleep(3000);
return gap;
// 힙 정렬의 경우
case 4:
printf("난수 %d개를 생성 중입니다...\n", number);
Sleep(3000);
generate_random_number(randomNum, bCheckExistOfNum, number);
printf("\n난수가 %d개 생성되었습니다.\n", number);
Sleep(3000);
printf("정렬 알고리즘을 시작합니다..\n");
startTime = clock();
Heap_Sort(randomNum, number); // 힙 정렬 실행.
endTime = clock();
printf("정렬 알고리즘이 완료되었습니다.\n");
gap=(float)(endTime-startTime)/(CLOCKS_PER_SEC); //계산
printf("총 수행 시간 : %f초\n", gap);
Sleep(3000);
printf("정렬된 결과를 출력합니다.\n");
Sleep(3000);
for(i = 0 ; i < number ; i++){
printf("%d ", randomNum[i]);
}
printf("\n정렬이 완료되었습니다.\n");
Sleep(3000);
return gap;
}
}
uint64_t *
prime_gen ( uint64_t number_of_primes,
uint8_t mode,
uint8_t bitsize )
{
uint64_t signal = 0;
uint64_t *array = malloc ( sizeof ( uint64_t ) * number_of_primes );
/*
Basic Error Checking.
1. malloc must not fail.
2. number_of_primes (n) must be non - negative.
3. bitsize must lie in [ 1 , 64 ].
*/
if ( array == NULL || number_of_primes == 0 || bitsize == 0 || bitsize > 64 )
{
return NULL;
}
/*
Seeding with time in order to make sure new random numbers
are generated everytime.
*/
srand ( time ( NULL ) );
/*
A flag to check whether to randomize every prime number or
generate n continuous primes.
*/
if ( mode == PRIME_RAND_CONT )
{
uint64_t random_number;
restart:random_number = generate_random_number ( bitsize );
mpz_t number , prime;
mpz_init ( number );
mpz_init ( prime );
mpz_init_set_ui ( number , random_number );
for( int i = 0 ; i < number_of_primes ; i++ )
{
mpz_nextprime ( prime , number );
array[ i ] = mpz_get_ui ( prime );
if ( bitsize != 64 && array[i] > (1ull << bitsize) )
{
/*
Failure from this function.
The function failed because, the n numbers to be generated reached the end of bitsize.
Restart the algorithm.
If n primes do not exist in the given bit range, then quit and return the generated array.
Example: Say the function is expected to generate 100 primes in the bitsize of 2.
The function is designed to fail after RETRY_LIMIT number of attempts.
Example: Say 10 primes of bitsize 7 are requested and the random_number chosen was 127.
The function is designed to retry again with a different random number.
*/
if ( signal++ < RETRY_LIMIT )
{
array[i] = -1;
goto restart;
}
else{
break;
}
}
mpz_init_set ( number , prime );
}
/*
Freeing multi - precision numbers in the memory.
*/
mpz_clear ( number );
mpz_clear ( prime );
}
else
{
mpz_t number , prime;
mpz_init ( number );
mpz_init ( prime );
for ( int i = 0 ; i < number_of_primes ; i ++ )
{
uint64_t random = generate_random_number ( bitsize );
mpz_init_set_ui ( number , random );
mpz_nextprime ( prime , number );
array[i] = mpz_get_ui ( prime );
if ( array[i] > ( 1ull << bitsize ) )
{
i--;
}
}
/*
Freeing multi - precision numbers in the memory.
*/
mpz_clear ( prime );
mpz_clear ( number );
}
return array;
}
int main(int args, char *argv[])
{
int server;
int receive_length, line_length;
char ip_addr[BUFSIZE];
char *line = NULL;
char buf[BUFSIZE];
FILE *fp = NULL;
SSL_CTX *ctx;
// Thread
pthread_t* threads[2];
if (pthread_mutex_init(&mutex, NULL) != 0)
{
printf("mutex init failed\n");
exit(-1);
}
my_ip_addr = get_ip_addr();
printf("My ip addr is: %s\n", my_ip_addr);
/* READ INPUT FILE */
fp = fopen("config_file", "r");
if(fp == NULL){
fprintf(stderr, "Error opening config file with name 'config_file'. Exiting.\n");
exit(1);
}
fp_output = fopen("Lab4-E-2.txt", "w");
if(fp_output == NULL){
fprintf(stderr, "Error opening config file with name 'Lab4-E-2.txt'. Exiting.\n");
exit(1);
}
printf("Reading input file...\n");
while(getline(&line, &line_length, fp) > 0){
if(strstr(line, "host_ip") != NULL){
sscanf(line, "host_ip: %s\n", ip_addr);
}
else if(strstr(line, "port") != NULL){
sscanf(line, "port: %d\n", &port);
}
else if(strstr(line, "range") != NULL){
sscanf(line, "range: %d\n", &range);
}
else if(strstr(line, "rate") != NULL){
sscanf(line, "rate: %d\n", &rate);
}
else{
fprintf(stderr, "Unrecognized line found: %s. Ignoring.\n", line);
}
}
fclose(fp);
/* FINISH READING INPUT FILE */
printf("Connecting to: %s:%d\n", ip_addr, port);
fprintf(fp_output,"Connecting to: %s:%d\n", ip_addr, port);
/* SET UP TLS COMMUNICATION */
SSL_library_init();
ctx = initialize_client_CTX();
server = open_port(ip_addr, port);
ssl = SSL_new(ctx);
SSL_set_fd(ssl, server);
/* FINISH SETUP OF TLS COMMUNICATION */
/* SEND HEART RATE TO SERVER */
if (SSL_connect(ssl) == -1){ //make sure connection is valid
fprintf(stderr, "Error. TLS connection failure. Aborting.\n");
ERR_print_errors_fp(stderr);
exit(1);
}
else {
printf("Client-Server connection complete with %s encryption\n", SSL_get_cipher(ssl));
fprintf(fp_output, "Client-Server connection complete with %s encryption\n", SSL_get_cipher(ssl));
fflush(fp_output);
display_server_certificate(ssl);
}
// Thread
pthread_create(&threads[0],NULL,worker_read,NULL);
while(1)
{
printf("Current settings: rate: %d, range: %d\n", rate, range);
heart_rate =
generate_random_number(AVERAGE_HEART_RATE-(double)range, AVERAGE_HEART_RATE+(double)range);
memset(buf,0,sizeof(buf)); //clear out the buffer
//populate the buffer with information about the ip address of the client and the heart rate
sprintf(buf, "Heart rate of patient %s is %4.2f", my_ip_addr, heart_rate);
printf("Sending message '%s' to server...\n", buf);
fprintf(fp_output,"Sending message '%s' to server...\n", buf);
fflush(fp_output);
SSL_write(ssl, buf, strlen(buf));
sleep(rate);
}
// Thread
pthread_join(threads[0],NULL);
/* FINISH HEART RATE TO SERVER */
//clean up operations
SSL_free(ssl);
close(server);
SSL_CTX_free(ctx);
return 0;
}
