C++ Timing::end方法代码示例

int main(){
    Timing timer;
#ifdef _DEBUG
    int size = 4;{
#else
    for(int size=1; size>0; size*=2){
#endif
    
        std::cout << "size: " << size << '\n';
        const int times = 10;
        Matrix a, b;
        a.resize(size);
        b.resize(size);
        a.randomize();
        b.randomize();

    
        timer.setDivisor(times);
    
   

        timer.start();
        for(int i=0; i<times; i++){
            Matrix c = MatrixMultiplication::recursive(a, b);
#ifdef _DEBUG
            c.print();
#endif
        }
        timer.end();
        timer.reportCPUtime();


        timer.start();
        for(int i=0; i<times; i++){
            Matrix c = MatrixMultiplication::strassen(a, b);
#ifdef _DEBUG
            c.print();
#endif
        }
        timer.end();
        timer.reportCPUtime();
    }

    return system("pause");
}

int main(int argc, char* argv[]){

    // Initialize MPI
    // Find out my identity in the default communicator
    MPI_Init(&argc, &argv);
    int rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    //used to store the final results
    std::vector<result_t> finalResults;
    //init the k value
    int k = 0;

    if(argc > 1){
        try{
            k = atoi(argv[1]);
            if(k < 0){
                throw "just need to throw a random exception to catch`";
            }
        }
        catch(...){
            std::cerr<<"k must be a positive integer"<<std::endl;
            return 0;
        }

    }

    //init the custom openmpi datatype
    MPI_Datatype ResultMpiType;
    //wrapper function to set up the custom type
    createMPIResultStruct(&ResultMpiType);




    // Master
    if (rank == 0){
        // ++++++++++++++++++++++++++++++
        // Master process
        // ++++++++++++++++++++++++++++++

        // check the arugmumants
        if (argc < 2){
            std::cout << "Usage: " << argv[0] << " [k value] [directory path:default(/cluster)]" << std::endl;
            return 0;
        }

        std::string folderPath;

        //set the default for the folder to use
        if(argc == 2){
            folderPath = "/cluster";
        }
        else{
            folderPath = argv[2];
        }


        Directory dir;

        if(!dir.set_path(folderPath)){
            std::cerr<<"Directory either not found or not a directory"<<std::endl;
            return 0;
        }


        //test for a correct k value
        try{
            k = atoi(argv[1]);
            if(k < 0){
                throw "just need to throw a random exception to catch`";
            }
        }
        catch(...){
            std::cerr<<"k must be a positive integer"<<std::endl;
            return 0;
        }

        auto test = dir.get_files();
        searchVector_t searchVector;
        Timing wallClock;
        double timeResults[NUM_TIME_RESULTS];

        //initlize timing holder
        for(int i = 0; i < NUM_TIME_RESULTS; i++){
            timeResults[i] = 0;
        }

        wallClock.start();
        //get the first vector the first file in the the directory as the search vector
        if(!getFirstVector(test.at(0),&searchVector)){
            std::cerr << "Couldn't get the search vector" << std::endl;
            return 0;
        }
        std::cout << "Sending work to workers" << std::endl;
        sendWork(test,&ResultMpiType,k,&finalResults,searchVector.data,timeResults);



        //wait for the workers to finish to collect the results
//.........这里部分代码省略.........

void EntityEngine::generatePathfindingNodes(NodeVector & nodes) {
	// lay a grid over the static entities
	Timing tm;

	const int resolutionFactor = 1;
	const float collisionMarginFactor = 2.5f;
	const float gridSize = 1.0f / float(resolutionFactor); // 0.5f;
	//const float neighbourDistance = sqrt(gridSize * gridSize * 2.0f) * 1.1f;

	float floatHighestY = 0;
	float floatLowestY = 100000000000.0f;
	for (Entity const* ent : getStaticEntities()) {
		floatHighestY = std::max(floatHighestY, ent->getPosition().y());
		floatLowestY = std::min(floatLowestY, ent->getPosition().y());
	}

	dropNavigationNodes(nodes);

	// protect against no entities
	if (getStaticEntities().size() == 0)
		return;

	assert(floatHighestY > floatLowestY);
	logging::Info() << "Generating navigation grid for lowY: " << floatLowestY << " highY: " << floatHighestY;

	const int highestY = int(std::ceil(floatHighestY));
	const int lowestY = int(std::floor(floatLowestY));
	const int spanY = highestY - lowestY;

	const float spanX = 15.0f;
	const int nodeCount = (spanX * resolutionFactor) * (spanY * resolutionFactor);

	nodes.resize(nodeCount);

	// with a resolution of 2 times the tile size
	const int sizeX = spanX * resolutionFactor;
	const int sizeY = (spanY * resolutionFactor);

	for (int y = 0; y < sizeY; y++) {
		for (int x = 0; x < sizeX; x++) {
			Vector2 pos(float(x) * gridSize, float(y) * gridSize + float(lowestY));

			// do only add if there is no collision object near by
			if (!checkForCollisionObject(pos, gridSize * collisionMarginFactor)) {
				const int thisNodeLocation = sizeX * y + x;
				NodePtr n = &nodes[thisNodeLocation];
				n->Location = pos;

				// connect to left
				if (x > 0) {
					// left same line
					n->Neighbours.push_back(&nodes[thisNodeLocation - 1]);

					// left lower
					if (y > 0) {
						n->Neighbours.push_back(&nodes[thisNodeLocation - 1 - sizeX]);
					}
					// left upper
					if (y < (sizeY - 1)) {
						n->Neighbours.push_back(&nodes[thisNodeLocation - 1 + sizeX]);
					}
				}
				if (x < (sizeX - 1)) {
					// right same line
					n->Neighbours.push_back(&nodes[thisNodeLocation + 1]);
					// right lower
					if (y > 0) {
						n->Neighbours.push_back(&nodes[thisNodeLocation + 1 - sizeX]);
					}
					// right upper
					if (y < (sizeY - 1)) {
						n->Neighbours.push_back(&nodes[thisNodeLocation + 1 + sizeX]);
					}
				}

				if (y > 0) {
					// lower one
					n->Neighbours.push_back(&nodes[thisNodeLocation - sizeX]);
				}
				if (y < (sizeY - 1)) {
					// upper one
					n->Neighbours.push_back(&nodes[thisNodeLocation + sizeX]);
				}
			}
		}
	}

	float dt = tm.end();
	logging::Info() << "Building the Pathfinding grid took " << dt << " seconds";
}

int doWork(MPI_Datatype* ResultMpiType,const int k){

    int rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    int MAX_RESULT_SIZE = k;

    char msg[MAX_MSG_SIZE];
    float cmpData[SEARCH_VECTOR_SIZE];
    double times[2];
    MPI_Status status;
    Timing parserTime;
    Timing searchTime;
    Timing workWallTime;

    workWallTime.start();
    std::chrono::duration<double> read_time_elapse;

    MPI_Recv(cmpData,
        SEARCH_VECTOR_SIZE,
        MPI_FLOAT,
        0,
        MPI_ANY_TAG,
        MPI_COMM_WORLD,
        &status);

    if(status.MPI_TAG != SEARCH_VECTOR){
        std::cout<< rank << " recieved terminate signal" << std::endl;
            return 0;
    }


    while (1) {
        // Receive a message from the master
        MPI_Recv(msg,           /* message buffer */
            MAX_MSG_SIZE,     /* buffer size */
            MPI_CHAR,       /* data item is an integer */
            0,              /* Receive from master */
            MPI_ANY_TAG,
                MPI_COMM_WORLD,     /* default communicator */
                &status);


        // Check if we have been terminated by the master
        // exit from the worker loop
        if (status.MPI_TAG == TERMINATE) {
            std::cout<< rank << " recieved terminate signal" << std::endl;
            return 0;
        }


        std::shared_ptr<MapString_t> nameMap(new MapString_t);
        std::vector<result_t> results;
        std::shared_ptr<std::vector<float>> dataVector(new std::vector<float>);
        Parser p(nameMap,dataVector);

        parserTime.start();
        if(!p.parse_file(msg,&read_time_elapse)){
            std::cerr<<"could not parse file: "<<msg<<std::endl;
            return 0;
        }
        parserTime.end();
        searchTime.start();
        int lineLength = p.get_line_length();
        int index = 0;
        for(auto& file : *nameMap){
            results.push_back(result_t());
            results.at(index).distance = findDist(lineLength,
                dataVector,file.second,cmpData);
            strcpy(results.at(index).fileName,file.first.c_str());
            index++;
        }


        std::sort(results.begin(),results.end(),resultPairSort);


        results.resize(MAX_RESULT_SIZE);

        searchTime.end();

        MPI_Send(results.data(),           /* message buffer */
             MAX_RESULT_SIZE,         /* buffer size */
             *ResultMpiType,              /* data item is an integer */
             0,                     /* destination process rank, the master */
             RESULTS,             /* user chosen message tag */
             MPI_COMM_WORLD);

        workWallTime.end();

        //add the times to an array to be sent to the master
        times[0] = parserTime.get_elapse();
        times[1] = searchTime.get_elapse();
        times[2] = workWallTime.get_elapse();

        //send out the timing results to be compiled
        MPI_Send(times,
            NUM_TIME_RESULTS,
            MPI_DOUBLE,
            0,
            TIMING,
//.........这里部分代码省略.........