static void slideshow_list_init(SlideShowData *ss, gint start_index)
{
if (ss->list_done)
{
g_list_free(ss->list_done);
ss->list_done = NULL;
}
if (ss->list) g_list_free(ss->list);
if (slideshow_random)
{
ss->list = generate_random_list(ss);
}
else
{
ss->list = generate_list(ss);
if (start_index >= 0)
{
/* start with specified image by skipping to it */
gint i = 0;
while(ss->list && i < start_index)
{
ss->list_done = g_list_prepend (ss->list_done, ss->list->data);
ss->list = g_list_remove(ss->list, ss->list->data);
i++;
}
}
}
}
/**
* Menu function that handles the event when someone clicks "Animate sorting"
* or "Exit." In the case of the former, we will set up the subwindows.
*
* @param value - the menu item clicked.
*/
void mymenu(int value) {
if (value == 1) {
mergesort_counter = 0; quicksort_counter = 0;
xs_mergesort = generate_random_list();
xs_quicksort = malloc(xs_size * sizeof(int));
cp_array(xs_mergesort, xs_quicksort, xs_size);
// push onto the mergesort stack
mergesort_stack = make_stack();
int *initial_array = malloc(xs_size * sizeof(int));
cp_array(xs_mergesort, initial_array, xs_size);
Node *initial_node = make_node(initial_array, xs_size, unsorted);
initial_node->start_index = 0;
initial_node->end_index = xs_size - 1;
push(mergesort_stack, initial_node);
// push onto the quicksort stack
quicksort_stack = make_stack();
Sublist *initial_list = make_sublist(0, xs_size - 1);
push(quicksort_stack, initial_list);
recreate_subwindows();
glutIdleFunc(update_lists);
in_intro = false;
}
if (value == 2)
exit(0);
}
// Main from original file copied to best tested multiple times
double testmain(uint_fast32_t N, uint_fast32_t M) {
uint_fast32_t object_size = N;
uint_fast32_t iters = M;
srand(object_size);
double* x = generate_random_list(object_size, 1000);
double* y = generate_random_list(object_size, 1000);
double* z = generate_random_list(object_size, 1000);
double* vx = generate_random_list(object_size, 1);
double* vy = generate_random_list(object_size, 1);
double* vz = generate_random_list(object_size, 1);
struct timespec requestStart, requestEnd;
clock_gettime(CLOCK_MONOTONIC, &requestStart);
for (uint_fast32_t i=0; i < iters; i++) {
for (uint_fast32_t j=0; j < object_size; j++) {
update_coords(j,x,y,z,vx,vy,vz);
}
}
clock_gettime(CLOCK_MONOTONIC, &requestEnd);
double timeTaken = (requestEnd.tv_sec + (requestEnd.tv_nsec / 1000000000.)) - (requestStart.tv_sec + (requestStart.tv_nsec / 1000000000.));
free(x);
free(y);
free(z);
free(vx);
free(vy);
free(vz);
return(((1000000. * timeTaken) / (object_size * iters)));
}
int main(int argc, char *argv[]){
const double bound = 1000.0;
const double v_bound = 1.0;
if (argc != 3){
printf("Required arguments: vector_length(N) and iterations_num(M)");
exit(EXIT_FAILURE);
}
// get command line args
uint32_t size = (uint32_t)atoi(argv[1]);
uint32_t iters = (uint32_t)atoi(argv[2]);
// set seed
srand(size);
// initialize points
double *x = generate_random_list(size, bound);
double *y = generate_random_list(size, bound);
double *z = generate_random_list(size, bound);
// initialize velocities
double *vx = generate_random_list(size, v_bound);
double *vy = generate_random_list(size, v_bound);
double *vz = generate_random_list(size, v_bound);
// time while we update coodinates iters number of times
struct timespec start, end;
clock_gettime(&start);
for(uint32_t i = 0; i < iters; i++){
update_coords(size, x, y, z, vx, vy, vz);
}
clock_gettime(&end);
//compute the checksum
double chksum = 0;
for (uint32_t i = 0; i < size; i++){
chksum += *(x + i) + *(y + i) + *(z + i);
//printf("x: %f y: %f z: %f, vx: %f vy: %f vz: %f checksum: %f iters: %u\n", *(x + i), *(y + i), *(z + i), *(vx + i), *(vy + i), *(vz + i), chksum, iters);
}
free(x);
free(y);
free(z);
free(vx);
free(vy);
free(vz);
// output
//convert nanoseconds to microseconds
//convert seconds to microseconds
double micro_sec = SEC_TO_MICRO * (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / NANO_TO_MICRO;
double mean_time = micro_sec/(size * iters);
printf("Mean time per coordinate: %f us\n", mean_time);
printf("Final checksum is: %f", chksum);
exit(EXIT_SUCCESS);
}
// Main:
int main(int argc, char* argv[]) {
if (argc != 3) {
printf("Required arguments: vector_length(N) and iterations_num(M)\n");
exit(-1);
}
uint_fast32_t object_size = atoi(argv[1]);
uint_fast32_t iters = atoi(argv[2]);
srand(object_size);
float* x = generate_random_list(object_size, 1000);
float* y = generate_random_list(object_size, 1000);
float* z = generate_random_list(object_size, 1000);
float* vx = generate_random_list(object_size, 1);
float* vy = generate_random_list(object_size, 1);
float* vz = generate_random_list(object_size, 1);
struct timespec requestStart, requestEnd;
clock_gettime(CLOCK_MONOTONIC, &requestStart);
for (uint_fast32_t i=0; i < iters; i++) {
for (uint_fast32_t j=0; j < object_size; j++) {
update_coords(j,x,y,z,vx,vy,vz);
}
}
clock_gettime(CLOCK_MONOTONIC, &requestEnd);
float chksum = (float)sum(x,object_size) + (float)sum(y,object_size) + (float)sum(z,object_size);
float timeTaken = (requestEnd.tv_sec + (requestEnd.tv_nsec / 1000000000.)) - (requestStart.tv_sec + (requestStart.tv_nsec / 1000000000.));
printf(" (1000000 * %f) / (%lu * %lu))\n",timeTaken,object_size,iters);
printf("Mean time per coordinate: %f us\n", ((1000000. * timeTaken) / (object_size * iters)));
printf("Final checksum is: %f\n", chksum);
_mm_free(x);
_mm_free(y);
_mm_free(z);
_mm_free(vx);
_mm_free(vy);
_mm_free(vz);
return(0);
}
int main(int argc, char** argv){
if(argc < 3){
printf("args: <size> <iters>\n");
return -1;
}
uint64_t size = 1 << atoi(argv[1]);
uint64_t iters = 1 << atoi(argv[2]);
srand(size);
float* x = generate_random_list(size,1000.);
float* y = generate_random_list(size,1000.);
float* z = generate_random_list(size,1.);
float* vx = generate_random_list(size,1.);
float* vy = generate_random_list(size,1.);
float* vz = generate_random_list(size,1.);
struct timespec start,end;
clock_gettime(CLOCK_MONOTONIC, &start);
for (uint64_t i=0; i < iters; i++) update_coords(size,x,y,z,vx,vy,vz);
clock_gettime(CLOCK_MONOTONIC, &end);
float elapsed = (end.tv_sec * BILLION + end.tv_nsec) - (start.tv_sec * BILLION + start.tv_nsec);
float avg = elapsed/(size * iters);
int checksum = 0;
for (uint64_t i=0; i<size; i++){
checksum += x[i] + y[i] + z[i];
}
fileout = fopen(outputFilename, "a");
fprintf(fileout, "%f\n",avg);
fclose(fileout);
printf("checksum is %d\n",checksum);
printf("Average Elapsed Time: %fns\n",avg);
return 0;
}
int main(){
uint32_t size = 0;
uint32_t iters = 0;
FILE * fp;
FILE * fp2;
FILE * fp3;
char * line = NULL;
size_t len = 0;
ssize_t read;
fp = fopen("HW1_P2.in", "r");
fp2 = fopen("HW1_P3.out","w");
fp3 = fopen("HW1_P3_DataToPlot.in", "w");
//Check if the file exists
if (fp == NULL)
exit(EXIT_FAILURE);
while ((read = getline(&line, &len, fp)) != -1) {
char *token;
char *rest = line;
token = strtok_r(rest, ",", &rest);
size = (uint32_t)atoi(token);
token = strtok_r(rest, ",", &rest);
iters = (uint32_t)atoi(token);
//printf("size:%u\n",size);
//printf("iters:%u\n",iters);
//Initialize pointers to arrays
double avg_avgtimes = 0;
double avgtimes[TIMES_PER_MEASUREMENTS] = {0};
for (uint32_t i=0;i<TIMES_PER_MEASUREMENTS;++i){
srand(size);
//Initialize arrays to zero
Float * x = calloc(size,sizeof(Float));
Float * y = calloc(size,sizeof(Float));
Float * z = calloc(size,sizeof(Float));
Float * vx = calloc(size,sizeof(Float));
Float * vy = calloc(size,sizeof(Float));
Float * vz = calloc(size,sizeof(Float));
//Generate our random arrays
generate_random_list(size,coord_bound,x);
generate_random_list(size,coord_bound,x);
generate_random_list(size,coord_bound,y);
generate_random_list(size,coord_bound,z);
generate_random_list(size,move_bound,vx);
generate_random_list(size,move_bound,vy);
generate_random_list(size,move_bound,vz);
clock_t begin, end;
double time_spent;
begin = clock();
for (uint32_t i=0;i<iters;++i){
update_coords(x,y,z,vx,vy,vz,size);
}
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
Float chksum = sum_array(x,size) + sum_array(y,size) + sum_array(z,size);
double avgtime = 1000000 * time_spent / (size * iters);
avgtimes[i] = avgtime;
//write detailed ouput
fprintf(fp2,"size: %u, iters: %u\n",size,iters);
fprintf(fp2,"total time:%f\n",time_spent);
fprintf(fp2,"Mean time per coordinate: %f\n",avgtime);
fprintf(fp2,"Final checksum is: %f\n",chksum);
//free memory
free(x);
free(y);
free(z);
free(vx);
free(vy);
free(vz);
}
//write output for the purpose of drawing a graph
avg_avgtimes = sum_array(avgtimes,TIMES_PER_MEASUREMENTS)/TIMES_PER_MEASUREMENTS;
fprintf(fp3,"%u,%f\n",size,avg_avgtimes);
}
//close files
fclose(fp);
fclose(fp2);
fclose(fp3);
if (line)
free(line);
return 0;
}
