Ejemplo n.º 1
0
int main(int argc, char ** argv) {

        char * fileName;
        TGraph *index;
        int totalres = 0;
        char * gotqueryFile = NULL;
        FILE * gotFile = NULL;
        ifstream f;
        unsigned int * gotreslist;
        uint gotres = 0;

        if (argc < 3) {
                printf("Usage: %s <graphfile> <queryfile> [<gotqueryfile>]\n", argv[0]);
                exit(1);
        }
        if (argc == 4) {
          savegotFile = 1;
          gotqueryFile = argv[3];
        }

        fileName = argv[1];

        f.open(fileName, ios::binary);
        index = TGraph::load(f);
        f.close();

        gotreslist = (uint*)malloc(sizeof(unsigned int)*BUFFER);

        int nqueries = 0;
        TimeQuery * queries = readQueries(argv[2], &nqueries);

        int i;

#ifndef EXPERIMENTS
	printf("We are checking the results... Experiments mode off.\n");
#endif

	startClockTime();
        for (i = 0; i < nqueries; i++) {
			fprintf(stderr, "Processing %d/%d\r", i, nqueries);
                TimeQuery query = queries[i];

		//cleaning vector of results

                switch(query.type) {
               case EDGE: {
                       gotres = index->edge_point(query.row, query.column, query.time);
                       //gotres = findEdge(tree, query.row, query.column, query.time);
                       *gotreslist = gotres;
                       break;
               }
               case EDGE_NEXT: {
                       //gotres = findEdgeInterval(tree, query.row, query.column, query.initime, query.endtime, 1);
                       gotres = index->edge_next(query.row, query.column, query.time);
                       *gotreslist = gotres;
                       break;
               }
               case EDGE_WEAK: {
                       //gotres = findEdgeInterval(tree, query.row, query.column, query.initime, query.endtime, 0);
                       gotres = index->edge_weak(query.row, query.column, query.initime, query.endtime);
                       *gotreslist = gotres;
                       break;
               }
               case EDGE_STRONG: {
                       //gotres = findEdgeInterval(tree, query.row, query.column, query.initime, query.endtime, 1);
                       gotres = index->edge_strong(query.row, query.column, query.initime, query.endtime);
                       *gotreslist = gotres;
                       break;
               }
                case DIRECT_NEIGHBORS: {
                        //get_neighbors_point(gotreslist, &index, query.row, query.time);
			index->direct_point(query.row, query.time, gotreslist);

                        break;
                }
                case REVERSE_NEIGHBORS: {
                       // get_reverse_point(gotreslist, &index, query.row, query.time);
			index->reverse_point(query.row, query.time, gotreslist);
                        break;
                }
                case DIRECT_NEIGHBORS_WEAK: {
                        //get_neighbors_weak(gotreslist, &index, query.row, query.initime, query.endtime);
			index->direct_weak(query.row, query.initime, query.endtime, gotreslist);
                        break;
                }
                case REVERSE_NEIGHBORS_WEAK: {
                        //get_reverse_weak(gotreslist, &index, query.row, query.initime, query.endtime);
			index->reverse_weak(query.row, query.initime, query.endtime, gotreslist);
                        break;
                }
                case DIRECT_NEIGHBORS_STRONG: {
                        //get_neighbors_strong(gotreslist, &index, query.row, query.initime, query.endtime);
			index->direct_strong(query.row, query.initime, query.endtime, gotreslist);
                        break;
                }
                case REVERSE_NEIGHBORS_STRONG: {
//                        get_reverse_strong(gotreslist, &index, query.row, query.initime, query.endtime);
			index->reverse_strong(query.row, query.initime, query.endtime, gotreslist);
                        break;
                }
		
		case SNAPSHOT: {
			gotres = index->snapshot(query.time);
			*gotreslist = gotres;
//                      gotres = findRange(tree, 0, tree->nNodesReal, 0, tree->nNodesReal, time)[0][0];
			break;
		}

        case CHANGE_POINT: {
            gotres = index->change_point(query.time);
            *gotreslist = gotres;
            break;
        }
        case CHANGE_INTERVAL: {
            gotres = index->change_interval(query.initime, query.endtime);
            *gotreslist = gotres;
            break;
        }
        case ACTIVED_POINT: {
            gotres = index->actived_point(query.time);
            *gotreslist = gotres;
            break;
        }
        case ACTIVED_INTERVAL: {
            gotres = index->actived_interval(query.initime, query.endtime);
            *gotreslist = gotres;
            break;
        }
        case DEACTIVED_POINT: {
            gotres = index->deactived_point(query.time);
            *gotreslist = gotres;
            break;
        }
        case DEACTIVED_INTERVAL: {
            gotres = index->deactived_interval(query.initime, query.endtime);
            *gotreslist = gotres;
            break;
        }

                }

#ifndef EXPERIMENTS
//                //Comentar para medir tiempos:
                if (CHECK_RESULTS) {
                  if (savegotFile) {
                    gotFile = fopen(gotqueryFile, "a");
                    switch(query.type) {
                    case EDGE: case EDGE_NEXT: {
                      fprintf(gotFile, "%d %d %d\n", query.row, query.column, query.time);
                      break;
                    }
                    case EDGE_WEAK: case EDGE_STRONG: {
                      fprintf(gotFile, "%d %d %d %d\n", query.row, query.column, query.initime, query.endtime);
                      break;
                    }
                    case DIRECT_NEIGHBORS: case REVERSE_NEIGHBORS: {
                      fprintf(gotFile, "%d %d\n", query.row, query.time);
                      break;
                    }
                    case DIRECT_NEIGHBORS_WEAK: case DIRECT_NEIGHBORS_STRONG:
                    case REVERSE_NEIGHBORS_WEAK: case REVERSE_NEIGHBORS_STRONG: {
                      fprintf(gotFile, "%d %d %d\n", query.row, query.initime, query.endtime);
                      break;
                    }
		    case SNAPSHOT: case CHANGE_POINT: case ACTIVED_POINT: case DEACTIVED_POINT:
		      fprintf(gotFile, "%d\n", query.time);
		    break;
                    }

                    if (query.type == EDGE || query.type == EDGE_NEXT || query.type == EDGE_WEAK || query.type == EDGE_STRONG || query.type == SNAPSHOT ||
                            query.type == CHANGE_POINT || query.type == CHANGE_INTERVAL || query.type == ACTIVED_POINT || query.type == ACTIVED_INTERVAL ||
                            query.type == DEACTIVED_POINT || query.type == DEACTIVED_INTERVAL) {
                      fprintf(gotFile,"%d\n", gotres);
                    } else {
                      uint j;
                      fprintf(gotFile, "%d", gotreslist[0]);
                      for (j = 1; j <= gotreslist[0]; j++) {
                        fprintf(gotFile, " %d", gotreslist[j]);
                      }
                      fprintf(gotFile, "\n");
                    }

                    fclose(gotFile);
                  }


                  int failcompare = 0;
                  if (query.type == EDGE || query.type == EDGE_NEXT || query.type == EDGE_WEAK || query.type == EDGE_STRONG || query.type == SNAPSHOT ||
                          query.type == CHANGE_POINT || query.type == CHANGE_INTERVAL || query.type == ACTIVED_POINT || query.type == ACTIVED_INTERVAL ||
                          query.type == DEACTIVED_POINT || query.type == DEACTIVED_INTERVAL) {
                    failcompare = (gotres != query.expectednres);
                  } else {
                    failcompare = compareRes(gotreslist, query.expectedres);
                    gotres = gotreslist[0];
                  }
                  if (failcompare) {
                    printf("query queryType=%d, row=%d, column=%d, time=%d, initime=%d, endtime=%d, expectedres=%d\n", query.type, query.row, query.column, query.time, query.initime, query.endtime, query.expectednres);
                    printf("count: got %d expected %d\n", gotres, query.expectednres);
                    
		    if ( ! (query.type == EDGE || query.type == EDGE_NEXT || query.type == EDGE_WEAK || query.type == EDGE_STRONG || query.type == SNAPSHOT ||
                    query.type == CHANGE_POINT || query.type == CHANGE_INTERVAL || query.type == ACTIVED_POINT || query.type == ACTIVED_INTERVAL ||
                    query.type == DEACTIVED_POINT || query.type == DEACTIVED_INTERVAL) ) {
		        printf("expected: "); print_arraysort(query.expectedres);
                        printf("got     : "); print_arraysort(gotreslist);
	    	    }
		    exit(1);
                  }
                  totalres += gotres;
                }

#else
                totalres += *gotreslist;
#endif




        }
        unsigned long microsecs = endClockTime()/1000; //to microsecs

//	printf("time = (%lf), %d queries, %lf micros/query, %lf micros/arista\n",
//	               difftime, nqueries,
//	               difftime/nqueries, difftime/totalres);

	        //printf("time = %lf (%ld) (%lf), %d queries, %lf micros/query, %lf micros/arista\n",
	         //      timeFromBegin(), realTimeFromBegin(), difftime, nqueries,
	          //     difftime/nqueries, difftime/totalres);


        // datasets.structura query_input num_queries totaloutput timeperquery timeperoutput
        printf("%s\t%s\t%ld\t%d\t%d\t%lf\t%lf\n", argv[1], argv[2],
                       microsecs, nqueries, totalres, (double)microsecs/nqueries, (double)microsecs/totalres);

        //destroyK2Tree(tree);

        exit(0);
}