int main()
{
struct Coord top, left, right;
left.x = -1;
left.y = 1;
top.x = 0;
top.y = -1;
right.x = 1;
right.y = 1;
drawSierpinski(0, left, top, right);
printf("index = %d, %d\n", index, rand_interval(0,255));
int tri = 0;
for (int i = 0; i < 120; i++){
for (int j = 0; j < 2; j++){
printf("(%f,%f,%d) ", verticesX[i][j], verticesY[i][j], rand_interval(0, 255));
}
printf("\nColor = (%f,%f,%f)", colors[i][0], colors[i][1], colors[i][2]);
getch();
printf("\n");
}
getch();
}
int main()
{
srand(time(NULL));
char * name = "Ayokunle Adeosun";
char output [MAX_SIZE *2];
long int amma = syscall(sys_hello, name, output, strlen(name));
printf("System call sys_hello returned %ld\n", amma);
printf("Output: %s\n", output);
amma = syscall(sys_table);
printf("System call sys_table returned %ld\n", amma);
int pid;
char pname [1024];
amma = -1;
while(amma == -1){
pid = rand_interval(1, 3000);
amma = syscall(sys_get_pname, pid, pname);
}
printf("System call sys_ get_pname %ld\n", amma);
printf("PID: %d Process: %s\n", pid, pname);
return 0;
}
void drawSierpinski(int iter, struct Coord a, struct Coord b, struct Coord c)
{
if (iter >= 8) // if lines are only 2 pixels in length
{
return;
}
else
{
drawSierpinski(iter + 1, a, mid(a, b), mid(a, c));
verticesX[index][0] = a.x;
verticesX[index][1] = mid(a, b).x;
verticesX[index][2] = mid(a, c).x;
verticesY[index][0] = a.y;
verticesY[index][1] = mid(a, b).y;
verticesY[index][2] = mid(a, c).y;
colors[index][0] = scale(rand_interval(0, 255),0,255,0,1);
colors[index][1] = scale(rand_interval(0, 255), 0, 255, 0, 1);
colors[index][2] = scale(rand_interval(0, 255), 0, 255, 0, 1);
drawSierpinski(iter + 1, mid(a, b), b, mid(b, c));
index++;
verticesX[index][0] = mid(a, b).x;
verticesX[index][1] = b.x;
verticesX[index][2] = mid(b, c).x;
verticesY[index][0] = mid(a, b).y;
verticesY[index][1] = b.y;
verticesY[index][2] = mid(b, c).y;
colors[index][0] = scale(rand_interval(0, 255), 0, 255, 0, 1);
colors[index][1] = scale(rand_interval(0, 255), 0, 255, 0, 1);
colors[index][2] = scale(rand_interval(0, 255), 0, 255, 0, 1);
drawSierpinski(iter + 1, mid(a, c), mid(b, c), c);
index++;
verticesX[index][0] = mid(a, c).x;
verticesX[index][1] = mid(b, c).x;
verticesX[index][2] = c.x;
verticesY[index][0] = mid(a, c).y;
verticesY[index][1] = mid(b, c).y;
verticesY[index][2] = c.y;
colors[index][0] = scale(rand_interval(0, 255), 0, 255, 0, 1);
colors[index][1] = scale(rand_interval(0, 255), 0, 255, 0, 1);
colors[index][2] = scale(rand_interval(0, 255), 0, 255, 0, 1);
}
}
int main()
{
int id, i = 0, isize = 100;
char *data;
key_t key = safe_ftok(".", 1);
if ((id = shmget(key, isize, 0600 | IPC_CREAT)) == -1)
{
perror("shmget");
exit(1);
}
printf("Created: id = %d\n", id);
data = (char *)shmat(id, NULL, 0);
if (*((int *)data) == -1)
{
perror("shmat: ");
exit(1);
}
data[isize] = 0;
while (1)
{
if (i == isize)
{
i = 0;
}
data[i] = rand_interval(97, 122);
i++;
sleep(1);
}
/* detach from the segment: */
if (shmdt(data) == -1)
{
perror("shmdt");
exit(1);
}
return 0;
}
void generateRandomTransform(FCL_REAL extents[6], Transform3f& transform)
{
FCL_REAL x = rand_interval(extents[0], extents[3]);
FCL_REAL y = rand_interval(extents[1], extents[4]);
FCL_REAL z = rand_interval(extents[2], extents[5]);
const FCL_REAL pi = 3.1415926;
FCL_REAL a = rand_interval(0, 2 * pi);
FCL_REAL b = rand_interval(0, 2 * pi);
FCL_REAL c = rand_interval(0, 2 * pi);
Matrix3f R;
eulerToMatrix(a, b, c, R);
Vec3f T(x, y, z);
transform.setTransform(R, T);
}
void generateRandomTransforms(FCL_REAL extents[6], std::vector<Transform3f>& transforms, std::size_t n)
{
transforms.resize(n);
for(std::size_t i = 0; i < n; ++i)
{
FCL_REAL x = rand_interval(extents[0], extents[3]);
FCL_REAL y = rand_interval(extents[1], extents[4]);
FCL_REAL z = rand_interval(extents[2], extents[5]);
const FCL_REAL pi = 3.1415926;
FCL_REAL a = rand_interval(0, 2 * pi);
FCL_REAL b = rand_interval(0, 2 * pi);
FCL_REAL c = rand_interval(0, 2 * pi);
{
Matrix3f R;
eulerToMatrix(a, b, c, R);
Vec3f T(x, y, z);
transforms[i].setTransform(R, T);
}
}
}
person *gen_create_person_fit(int id,int num_of_gen, int num_of_parents,int row_swapping,int min_count,int max_count,double mutation_rate,gsl_rng *r){
int i,j;
/*int j;*/
R1_R2_auxiliary *auxiliary;
person *new_person;
new_person = (person*)calloc(1, sizeof(person));
new_person->id=id;
for (i=0;i<genes_per_person;i++){
new_person->gene_counts[i]=rand_interval(min_count,max_count);
}
/*for(i=0;i<genes_per_person;i++){
new_person->vector_of_signs[i]=1;
}*/
for(i=0;i<genes_per_person;i++){
new_person->vector_of_signs[i]=0;
if(i%2==0)
new_person->vector_of_signs[i]=1; /* first generation so gene_counts always positive on the vector -> 1 */
}
/* printf("Creating Inheritance\n");*/
if(num_of_parents){
if(row_swapping){
auxiliary=choose_fitted_father_dependencies_combined_row_swapping(num_of_gen);
}
else{
auxiliary=choose_fitted_father_dependencies_combined_R1R2_swapping(num_of_gen);
}
/* printf("Atomo %d\n",id); */
}
else{
auxiliary=choose_fitted_father_dependencies_no_combinations(num_of_gen);
}
/*printf("Created Person\n");*/
for(i=0;i<genes_per_person;i++){
new_person->gene_R1[i]=auxiliary->R1[i];
new_person->gene_R2[i]=auxiliary->R2[i];
}/*
printf("\n");
for (i = 0; i < max_genes_per_person; i++){
for(j=0;j<max_genes_per_person;j++){
printf("%f ",new_person->gene_interactions[i][j]);
}
printf("\n");
}
*/
new_person=create_mutations(new_person,mutation_rate,r);
/*for(i=0;i<genes_per_person;i++){
if(new_person->gene_R1[i]>100) printf("neo R1[%d]=%d\n",i,new_person->gene_R1[i]);
}
for(i=0;i<genes_per_person;i++){
if(new_person->gene_R2[i]>100) printf("neo R2[%d]=%d\n",i,new_person->gene_R2[i]);
}
*/
for(i=0;i<genes_per_person;i++){
for(j=0;j<genes_per_person;j++){
/*new_person->gene_interactions[i][j]=random_normal_distrubution(0,sqrt(10));*/
new_person->gene_interactions[i][j]=create_gene_interactions(new_person->gene_R1[i],new_person->gene_R2[j]);
/* printf("%f ",create_gene_interactions(new_auxiliary->R1[i],new_auxiliary->R2[j]));
extract_person(R1[i],R2[j]);*/
/*if (new_person->gene_interactions[i][j]<0) printf("Arnitiko gene interaction %f\n",new_person->gene_interactions[i][j]);
*/
}
/* printf("\n"); */
}
free(auxiliary);
return new_person;
}
/*
* Given a mean of an exponential distribtuion, returns a random value
*/
int exponentialRand(float mean) {
int random = rand_interval(0, 100);
double randomDigit = (double) random/100;
double randomNumber = -mean*log(randomDigit);
return (int) randomNumber;
}
void generateRandomTransform_ccd(FCL_REAL extents[6], std::vector<Transform3f>& transforms, std::vector<Transform3f>& transforms2, FCL_REAL delta_trans[3], FCL_REAL delta_rot, std::size_t n,
const std::vector<Vec3f>& vertices1, const std::vector<Triangle>& triangles1,
const std::vector<Vec3f>& vertices2, const std::vector<Triangle>& triangles2)
{
transforms.resize(n);
transforms2.resize(n);
for(std::size_t i = 0; i < n;)
{
FCL_REAL x = rand_interval(extents[0], extents[3]);
FCL_REAL y = rand_interval(extents[1], extents[4]);
FCL_REAL z = rand_interval(extents[2], extents[5]);
const FCL_REAL pi = 3.1415926;
FCL_REAL a = rand_interval(0, 2 * pi);
FCL_REAL b = rand_interval(0, 2 * pi);
FCL_REAL c = rand_interval(0, 2 * pi);
Matrix3f R;
eulerToMatrix(a, b, c, R);
Vec3f T(x, y, z);
Transform3f tf(R, T);
std::vector<std::pair<int, int> > results;
{
transforms[i] = tf;
FCL_REAL deltax = rand_interval(-delta_trans[0], delta_trans[0]);
FCL_REAL deltay = rand_interval(-delta_trans[1], delta_trans[1]);
FCL_REAL deltaz = rand_interval(-delta_trans[2], delta_trans[2]);
FCL_REAL deltaa = rand_interval(-delta_rot, delta_rot);
FCL_REAL deltab = rand_interval(-delta_rot, delta_rot);
FCL_REAL deltac = rand_interval(-delta_rot, delta_rot);
Matrix3f R2;
eulerToMatrix(a + deltaa, b + deltab, c + deltac, R2);
Vec3f T2(x + deltax, y + deltay, z + deltaz);
transforms2[i].setTransform(R2, T2);
++i;
}
}
}
void generateRandomTransforms(FCL_REAL extents[6], FCL_REAL delta_trans[3], FCL_REAL delta_rot, std::vector<Transform3f>& transforms, std::vector<Transform3f>& transforms2, std::size_t n)
{
transforms.resize(n);
transforms2.resize(n);
for(std::size_t i = 0; i < n; ++i)
{
FCL_REAL x = rand_interval(extents[0], extents[3]);
FCL_REAL y = rand_interval(extents[1], extents[4]);
FCL_REAL z = rand_interval(extents[2], extents[5]);
const FCL_REAL pi = 3.1415926;
FCL_REAL a = rand_interval(0, 2 * pi);
FCL_REAL b = rand_interval(0, 2 * pi);
FCL_REAL c = rand_interval(0, 2 * pi);
{
Matrix3f R;
eulerToMatrix(a, b, c, R);
Vec3f T(x, y, z);
transforms[i].setTransform(R, T);
}
FCL_REAL deltax = rand_interval(-delta_trans[0], delta_trans[0]);
FCL_REAL deltay = rand_interval(-delta_trans[1], delta_trans[1]);
FCL_REAL deltaz = rand_interval(-delta_trans[2], delta_trans[2]);
FCL_REAL deltaa = rand_interval(-delta_rot, delta_rot);
FCL_REAL deltab = rand_interval(-delta_rot, delta_rot);
FCL_REAL deltac = rand_interval(-delta_rot, delta_rot);
{
Matrix3f R;
eulerToMatrix(a + deltaa, b + deltab, c + deltac, R);
Vec3f T(x + deltax, y + deltay, z + deltaz);
transforms2[i].setTransform(R, T);
}
}
}
void throughput_test(const uint32_t time_interval_list[],const uint32_t time_interval_list_len,
const uint32_t key_len, const uint32_t value_len, const uint32_t hash, const double get_per, const double set_per){
//printf("\nstart_new_cycle: ti-%u, k-%u, v-%u, h-%u, get-%f, set-%f\n",time_interval,key_len,value_len,hash,get_per,set_per);
//Initialize files and associate appropriate file pointers to them
FILE * fp_key, * fp_val, * fp_op, * fp_out;
Initialize_files(&fp_key,&fp_val,&fp_op,&fp_out,
key_len,value_len, hash, get_per, set_per);
//Create and fill parameter pools from the input files
char key_pool[POOL_SIZE][KEY_MAX] = {0};
char value_pool[POOL_SIZE][VAL_MAX] = {0};
char ops_pool[POOL_SIZE][OPLENGTH] = {0};
if (fp_key!=NULL&&fp_val!=NULL&&fp_op!=NULL){
fill_parameters_pools(fp_key,fp_val,fp_op, key_pool, value_pool, ops_pool);
}
else{
printf("NULL file descriptors");
}
//a flag used to check whether we have passed sustained througput of the current parameters combinations
uint32_t limit_attained = 0;
//Begin The main loop - increase the number of requests each time
for (uint32_t i = 0; i<time_interval_list_len; i++){
uint32_t time_interval = time_interval_list[i];
uint64_t request_num = (uint64_t)(1000000.0/(double)time_interval);
double response_time[TESTS_NUM] = {0};
double response_time_median = 0;
//Test a bundle several times and take the mean response time
for (uint32_t j=0;j<TESTS_NUM;j++){
cache_t cache = create_cache((uint64_t)(POOL_SIZE)*(uint64_t)VAL_MAX);
clock_t begin,end;
double timeTaken_sec = 0;
double sleep_time_sec = 0;
double total_sleep_time_sec = 0;
double total_time_ms = 0;
double time_interval_sec = (double)time_interval*0.0000001;
double waiting_time_ms = 0;
uint32_t waiting_rounds = 0;
//Number of responses that haven't been received
uint32_t waiting_responses = 0;
//Set up files to be read
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(cache->sockfd, &readfds);
FD_SET(cache->sockfd_udp, &readfds);
//Set up buffers that store messages
char buffer[MAXDATASIZE];
bzero(buffer,MAXDATASIZE);
char remaining_message[MAXDATASIZE];
bzero(remaining_message,MAXDATASIZE);
char remaining_message_udp[MAXDATASIZE];
bzero(remaining_message_udp,MAXDATASIZE);
//Send a certain number of requests
for (uint32_t i=1;i<=request_num;i++){
//Initialize a random request
char key[KEY_MAX] = {0}; strncpy(key, key_pool[rand_interval(0,POOL_SIZE-1)],KEY_MAX);
char value[VAL_MAX] = {0}; strncpy(value,value_pool[rand_interval(0,POOL_SIZE-1)],VAL_MAX);
char op[OPLENGTH] = {0}; strcpy(op, ops_pool[rand_interval(0,POOL_SIZE-1)]);
bzero(buffer,MAXDATASIZE);
generate_a_request(buffer,key,value,op);
begin = clock();
if (strncmp(op,"GET",3)==0){
if (send(cache->sockfd_udp,buffer,strlen(buffer), 0) < 0) {error("ERROR sendto to socket");}
}
else{
if (send(cache->sockfd,buffer,strlen(buffer), 0) < 0) {error("ERROR send to socket");}
}
waiting_responses++;
//Update the number of responses that haven't arrived
waiting_responses-=check_response(cache,time_interval,readfds,remaining_message, remaining_message_udp);
end = clock();
timeTaken_sec = ((double)(end-begin)+waiting_responses*time_interval)/CLOCKS_PER_SEC;
total_time_ms += (timeTaken_sec*1000);
//printf("total_time:%fms,timeTaken:%fus\n",total_time_ms,timeTaken_sec*1000000);
//sleep if there is time left
if (timeTaken_sec<=(time_interval_sec)){
sleep_time_sec = time_interval_sec-timeTaken_sec;
sleep(sleep_time_sec);
total_sleep_time_sec += sleep_time_sec;
}
//printf("loop:%u,waiting_responses:%u\n",i,waiting_responses);
}
//Wait for the remaining responses on the way from the server
//printf("begin to wait\n");
begin = clock();
while (waiting_responses>0){
waiting_rounds++;
//printf("waiting responses:%u\n",waiting_responses);
uint32_t new_responses = check_response(cache,time_interval,readfds,remaining_message,remaining_message_udp);
if (new_responses>0){
waiting_rounds = 0;
waiting_responses-=new_responses;
}
//If it waits for more than 10000 rounds, the messages probably will never come
if (waiting_rounds>30000){
break;
}
}
end = clock();
waiting_time_ms = ((double)(end-begin)*1000)/CLOCKS_PER_SEC;
total_time_ms += waiting_time_ms;
response_time[j] = total_time_ms/(double)request_num;
//If we have passed sustained througput, break the test for the current combination of the input parameters
printf("total_time:%fms,response_time:%fms\n",total_time_ms,response_time[j]);
destroy_cache(cache);
}
response_time_median = median(response_time,TESTS_NUM);
fprintf(fp_out,"%"PRIu64",%f\n",request_num,response_time_median);
if (response_time_median>1.5){
limit_attained = 1;
break;
}
if (limit_attained==1){
break;
}
}
fclose(fp_key);
fclose(fp_val);
fclose(fp_op);
fclose(fp_out);
}
