/* * Main function * @pram int argc * @pram char** argv */ int main(int argc, char * argv[]) { /* *Configure the program to use the command line args */ srand(time(NULL)); parseCommandLineArgs(argc, argv, 0); /* * Timing Variables */ std::clock_t time_start; std::clock_t time_end; /* * Input/Result containers */ int total_comparisons; std::vector<IsoRank_Result> isoRank_results; std::vector<DenseMatrix1D<DataType>* >input_graphs; if(G_PRINT) std::cout << "Reading " << G_NUMBER_OF_FILES << " graphs from: " << G_DIR_PATH << std::endl; std::ostringstream itos_converter; time_start = std::clock(); /* * Reading the graphs and storing them */ for(int i = 1; i <= G_NUMBER_OF_FILES; i++) { try { itos_converter << G_DIR_PATH << i << G_FILE_EXTENSION; input_graphs.push_back(new DenseMatrix1D<DataType>(itos_converter.str())); itos_converter.str(""); //clearing the stream itos_converter.clear(); } catch (std::exception& e) { std::cerr <<"Exception: " << e.what() << '\n' << std::endl; itos_converter.str(""); itos_converter.clear(); } } total_comparisons = (0.5*(input_graphs.size()-1)*input_graphs.size()); time_end = std::clock(); if(G_PRINT) std::cout << input_graphs.size() << " of " << G_NUMBER_OF_FILES << " graphs were successfully read in " << timeElapsed(time_start, time_end) << "(ms)." << std::endl; time_start = std::clock(); for (int i = 0; i < input_graphs.size(); i++) { for (int j = i +1; j < input_graphs.size(); j++) { try { if (G_USE_ISORANK) { isoRank_results.push_back(isoRank(*input_graphs[i], *input_graphs[j], G_GRAPH_MATCHING_ALGORITHM)); } if (G_USE_GPGM) { //GPGM(mat1,mat2); } } catch (std::exception& e) { std::cerr << " Exception: " << e.what() << std::endl; } } } time_end = std::clock(); //printing the results if (G_PRINT) { std::cout << "Computed IsoRank successfully for " << G_NUMBER_OF_FILES << " graphs in " << timeElapsed(time_start, time_end) << "(ms)." << std::endl; std::cout << "Frob_norms: "; for (int i=0; i < isoRank_results.size(); i++) { std::cout<< isoRank_results[i].frob_norm << ", "; } std::cout<<std::endl; } typename std::vector<IsoRank_Result>::iterator res_it; for ( res_it = isoRank_results.begin() ; res_it < isoRank_results.end(); ++res_it ) { delete [] res_it->assignments; } typename std::vector<DenseMatrix1D<DataType>* >::iterator graph_it; for ( graph_it = input_graphs.begin() ; graph_it < input_graphs.end(); ++graph_it ) { delete *graph_it; } return 0; }
/* * Main function * @pram int argc * @pram char** argv */ int main(int argc, char * argv[]) { srand(time(NULL)); /* * MPI Variables */ int num_procs; int ID; MPI_Status stat; /* * MPI constant Tags */ const int MASTER_ID = 0; const int TAG_1 = 4; const int TAG_2 = 10; const int TAG_3 = 15; /* * MPI Initialization calls */ if (MPI_Init(&argc, &argv) != MPI_SUCCESS) { std::cout << "Failed To Initialize MPI" << std::endl; //MPI_Abort(); } MPI_Comm_size (MPI_COMM_WORLD, &num_procs); MPI_Comm_rank (MPI_COMM_WORLD, &ID); /* *Configure the program to use the command line args */ parseCommandLineArgs(argc, argv, ID); /* * Timing Variables */ std::clock_t time_start; std::clock_t time_end; /* * Result variables */ int total_comparisons; std::vector<IsoRank_Result> isoRank_results; //======================================================================*MASTER NODE*============================================================================== if (ID == MASTER_ID) { if(G_PRINT) std::cout << "Reading " << G_NUMBER_OF_FILES << " graphs from: " << G_DIR_PATH << std::endl; time_start = std::clock(); std::ostringstream itos_converter; std::vector<SymMatrix<DataType>* >input_graphs; /* * Reading the graphs and storing them */ for(int i = 1; i <= G_NUMBER_OF_FILES; i++) { try { itos_converter << G_DIR_PATH << i << G_FILE_EXTENSION; input_graphs.push_back(new SymMatrix<DataType>(itos_converter.str())); itos_converter.str(""); //clearing the stream itos_converter.clear(); } catch (std::exception& e) { std::cerr <<"Exception: " << e.what() << '\n' << std::endl; itos_converter.str(""); itos_converter.clear(); } } total_comparisons = (0.5*(input_graphs.size()-1)*input_graphs.size()); time_end = std::clock(); if(G_PRINT) std::cout << input_graphs.size() << " of " << G_NUMBER_OF_FILES << " graphs were successfully read in " << timeElapsed(time_start, time_end) << "(ms)." << std::endl; /* * Sending the graphs to worker nodes. */ time_start = std::clock(); int dest_ID = 1; int recv_counter = 0; for (int i = 0; i < input_graphs.size(); i++) { for(int j = i + 1; j < input_graphs.size(); j++) { // Send a pair of graphs to all the worker nodes if (dest_ID < num_procs) { input_graphs[i]->MPI_Send_Matrix(dest_ID, TAG_1 * dest_ID); input_graphs[j]->MPI_Send_Matrix(dest_ID, TAG_1 * dest_ID + TAG_2); if(G_DEBUG) std::cout <<"Master: sending matrix to ID: " << dest_ID << std::endl; dest_ID++; } // Send additional pairs upon worker node's request else { int dest; //Recv workers ID MPI_Recv(&dest, 1, MPI_INT, MPI_ANY_SOURCE, TAG_1 + TAG_2, MPI_COMM_WORLD,&stat); if(G_DEBUG) std::cout <<"Master: received request for more graphs from: "<< dest<< std::endl; //Collect the result from worker isoRank_results.push_back(MPI_Recv_IsoRank_Result(dest, TAG_1 * dest + TAG_3, stat)); recv_counter++; if(G_DEBUG) std::cout <<"Master: results were received "<< dest<< std::endl; //Send more graphs to worker node input_graphs[i]->MPI_Send_Matrix(dest, TAG_1 * dest); input_graphs[j]->MPI_Send_Matrix(dest, TAG_1 * dest + TAG_2); if(G_DEBUG) std::cout <<"Master: sending more graphs to: "<< dest<< std::endl; } } } // Recv the remaining result while (recv_counter < total_comparisons) { int dest; //Recv workers ID MPI_Recv(&dest, 1, MPI_INT, MPI_ANY_SOURCE, TAG_1 + TAG_2, MPI_COMM_WORLD,&stat); if(G_DEBUG) std::cout <<"Master: received request for more graphs from: "<< dest<< std::endl; //Collect the result from worker isoRank_results.push_back(MPI_Recv_IsoRank_Result(dest, TAG_1 * dest + TAG_3, stat)); recv_counter++; if(G_DEBUG) std::cout <<"Master: results were received."<< dest<< std::endl; } //Terminating the slaves by sending a 0*0 matrix to nodes for(int i=1; i < num_procs; i++) { SymMatrix<DataType> emptyMat(0); emptyMat.MPI_Send_Matrix (i, TAG_1*i); emptyMat.MPI_Send_Matrix (i, TAG_1*i+ TAG_2); if (G_DEBUG) std::cout <<"Master: sending terminate signal to ID: " << i << std::endl; } time_end = std::clock(); //printing the results if (G_PRINT) { std::cout << "Master: Computed IsoRank successfully for " << G_NUMBER_OF_FILES << " graphs in " << timeElapsed(time_start, time_end) << "(ms)." << std::endl; std::cout<< "Master: " <<isoRank_results.size() << " results were received.\n frob_norms: "; for (int i=0; i < isoRank_results.size(); i++) { std::cout<< isoRank_results[i].frob_norm << ", "; } std::cout<<std::endl; } typename std::vector<IsoRank_Result>::iterator res_it; for ( res_it = isoRank_results.begin() ; res_it < isoRank_results.end(); ++res_it ) { delete [] res_it->assignments; } typename std::vector<SymMatrix<DataType>* >::iterator graph_it; for ( graph_it = input_graphs.begin() ; graph_it < input_graphs.end(); ++graph_it ) { delete *graph_it; } } //======================================================================*WORKER NODES*============================================================================== else { while(true) { //Recv graphs from the master DenseMatrix1D<DataType> mat1 (MASTER_ID, TAG_1 * ID ,stat); DenseMatrix1D<DataType> mat2 (MASTER_ID, TAG_1 * ID + TAG_2 ,stat); if (G_DEBUG) std::cout << "Process "<< ID << " : received graphs from master"<< std::endl; //Terminating the while loop if the matrices are 0*0 if (mat1.getNumberOfRows() == 0 && mat2.getNumberOfRows() == 0) { if (G_DEBUG) std::cout << "Process "<< ID << ": received terminate signal from master"<< std::endl; break; } struct IsoRank_Result result; try { if (G_USE_ISORANK) { if (G_DEBUG) std::cout << "Process " << ID << ": isoRank: started." << std::endl; result = isoRank(mat1, mat2, G_GRAPH_MATCHING_ALGORITHM); if (G_DEBUG) std::cout << "Process " << ID << ": isoRank: end." << std::endl; } if (G_USE_GPGM) { //GPGM(mat1,mat2); } if (G_DEBUG) std::cout << "Process "<< ID << " :requesting for more graphs from master" << std::endl; //Sending the ID to master for more graphs MPI_Send(&ID, 1, MPI_INT, MASTER_ID, TAG_1 + TAG_2, MPI_COMM_WORLD); if (G_DEBUG) std::cout << "Process "<< ID << ": :sending result to master" << std::endl; //Sending results to master MPI_Send_IsoRank_Result(result, MASTER_ID , TAG_1 * ID + TAG_3); delete [] result.assignments; } catch (std::exception& e) { std::cerr << "Process "<< ID << " Exception: " << e.what() << std::endl; } } } if(G_PRINT) std::cout << "Process: "<< ID << " terminated." << std::endl; MPI_Finalize(); return 0; }
/* * Main function * @pram int argc * @pram char** argv */ int main(int argc, char * argv[]) { srand(time(NULL)); /* * MPI Variables */ int num_procs; int ID; MPI_Status stat; /* * MPI constant Tags */ const int MASTER_ID = 0; const int TAG_1 = 4; const int TAG_2 = 10; const int TAG_3 = 15; /* * MPI Initialization calls */ if (MPI_Init(&argc, &argv) != MPI_SUCCESS) { std::cout << "Failed To Initialize MPI" << std::endl; //MPI_Abort(); } MPI_Comm_size (MPI_COMM_WORLD, &num_procs); MPI_Comm_rank (MPI_COMM_WORLD, &ID); /* *Configure the program to use the command line args */ parseCommandLineArgs(argc, argv, ID); /* * Timing Variables */ std::clock_t time_start; std::clock_t time_end; /* * Result variables */ int total_comparisons; int number_of_graphs; std::vector<IsoRank_Result> isoRank_results; //======================================================================*MASTER NODE*============================================================================== if (ID == MASTER_ID) { if(G_PRINT) std::cout << "Reading " << G_NUMBER_OF_FILES << " graphs from: " << G_DIR_PATH << std::endl; time_start = std::clock(); std::ostringstream itos_converter; std::vector<SymMatrix<DataType>* >input_graphs; /* * Reading the graphs and storing them */ for(int i = 1; i <= G_NUMBER_OF_FILES; i++) { try { itos_converter << G_DIR_PATH << i << G_FILE_EXTENSION; input_graphs.push_back(new SymMatrix<DataType>(itos_converter.str())); itos_converter.str(""); //clearing the stream itos_converter.clear(); } catch (std::exception& e) { std::cerr <<"Exception: " << e.what() << '\n' << std::endl; itos_converter.str(""); itos_converter.clear(); } } number_of_graphs = input_graphs.size(); total_comparisons = (0.5*(number_of_graphs-1)*number_of_graphs); time_end = std::clock(); if(G_PRINT) std::cout << input_graphs.size() << " of " << G_NUMBER_OF_FILES << " graphs were successfully read in " << timeElapsed(time_start, time_end) << "(ms)." << std::endl; /* * Sending the graphs to worker nodes. */ time_start = std::clock(); MPI_Bcast (&number_of_graphs, 1 , MPI_INT, MASTER_ID, MPI_COMM_WORLD); if(G_DEBUG) std::cout <<"Master: sending "<<number_of_graphs << " graphs to all"<< std::endl; for (int i = 0; i < input_graphs.size(); i++) { input_graphs[i]->MPI_Bcast_Send_Matrix(MASTER_ID); } /* * Collecting the results from the worker nodes. */ int recv_counter = 0; while (recv_counter < total_comparisons) { int dest; //Recv workers ID MPI_Recv(&dest, 1, MPI_INT, MPI_ANY_SOURCE, TAG_1 + TAG_2, MPI_COMM_WORLD,&stat); if(G_DEBUG) std::cout <<"Master: received signal to receive result from: "<< dest<< std::endl; //Collect the result from worker isoRank_results.push_back(MPI_Recv_IsoRank_Result(dest, TAG_1 * dest + TAG_3, stat)); recv_counter++; if(G_DEBUG) std::cout <<"Master: results were received."<< dest<< std::endl; } time_end = std::clock(); //printing the results if (G_PRINT) { std::cout << "Master: Computed IsoRank successfully for " << G_NUMBER_OF_FILES << " graphs in " << timeElapsed(time_start, time_end) << "(ms)." << std::endl; std::cout<< "Master: " << isoRank_results.size() << " results were received.\n frob_norms: "; for (int i=0; i < isoRank_results.size(); i++) { std::cout<< isoRank_results[i].frob_norm << ", "; } std::cout<<std::endl; } typename std::vector<IsoRank_Result>::iterator res_it; for ( res_it = isoRank_results.begin() ; res_it < isoRank_results.end(); ++res_it ) { delete [] res_it->assignments; } typename std::vector<SymMatrix<DataType>* >::iterator graph_it; for ( graph_it = input_graphs.begin() ; graph_it < input_graphs.end(); ++graph_it ) { delete *graph_it; } } //======================================================================*WORKER NODES*============================================================================== else { std::vector<DenseMatrix1D<DataType>* > recv_graphs; MPI_Bcast (&number_of_graphs, 1, MPI_INT, MASTER_ID, MPI_COMM_WORLD); for (int i = 0; i < number_of_graphs; i++) { recv_graphs.push_back(new DenseMatrix1D<DataType>(MASTER_ID, stat)); } if (G_DEBUG) std::cout << "Process "<< ID << " : received " << number_of_graphs << " graphs from master"<< std::endl; Offset offset; offset.setValues(ID, num_procs, number_of_graphs); int A, B; for (int i = offset.i_start; i <= offset.i_end; i++) { if (i == offset.i_start) { A = offset.j_start; } else { A = i+1; } if (i == offset.i_end) { B = offset.j_end; } else { B = number_of_graphs - 1; } for (int j = A; j <= B; j++) { struct IsoRank_Result result; try { if (G_USE_ISORANK) { if (G_DEBUG) std::cout << "Process " << ID << ": isoRank: started." << i << " " << j << std::endl; result = isoRank(*recv_graphs[i], *recv_graphs[j], G_GRAPH_MATCHING_ALGORITHM); if (G_DEBUG) std::cout << "Process " << ID << ": isoRank: end." << std::endl; } if (G_USE_GPGM) { //GPGM(mat1,mat2); } //Sending the ID to master for more graphs MPI_Send(&ID, 1, MPI_INT, MASTER_ID, TAG_1 + TAG_2, MPI_COMM_WORLD); if (G_DEBUG) std::cout << "Process "<< ID << " :sending result to master" << std::endl; //Sending results to master MPI_Send_IsoRank_Result(result, MASTER_ID , TAG_1 * ID + TAG_3); delete []result.assignments; } catch (std::exception& e) { std::cerr << "Process "<< ID << " Exception: " << e.what() << std::endl; } } } typename std::vector<DenseMatrix1D<DataType>* >::iterator graph_it; for ( graph_it = recv_graphs.begin() ; graph_it < recv_graphs.end(); ++graph_it ) { delete *graph_it; } } if(G_PRINT) std::cout << "Process: "<< ID << " terminated." << std::endl; MPI_Finalize(); return 0; }
void processFile(const char* input_filename, Config& config, GCodeExport& gcode, bool firstFile) { for(unsigned int n=1; n<16;n++) gcode.setExtruderOffset(n, config.extruderOffset[n]); double t = getTime(); log("Loading %s from disk...\n", input_filename); SimpleModel* m = loadModel(input_filename, config.matrix); if (!m) { log("Failed to load model: %s\n", input_filename); return; } log("Loaded from disk in %5.3fs\n", timeElapsed(t)); log("Analyzing and optimizing model...\n"); OptimizedModel* om = new OptimizedModel(m, Point3(config.objectPosition.X, config.objectPosition.Y, -config.objectSink)); for(unsigned int v = 0; v < m->volumes.size(); v++) { log(" Face counts: %i -> %i %0.1f%%\n", (int)m->volumes[v].faces.size(), (int)om->volumes[v].faces.size(), float(om->volumes[v].faces.size()) / float(m->volumes[v].faces.size()) * 100); log(" Vertex counts: %i -> %i %0.1f%%\n", (int)m->volumes[v].faces.size() * 3, (int)om->volumes[v].points.size(), float(om->volumes[v].points.size()) / float(m->volumes[v].faces.size() * 3) * 100); } delete m; log("Optimize model %5.3fs \n", timeElapsed(t)); //om->saveDebugSTL("c:\\models\\output.stl"); log("Slicing model...\n"); vector<Slicer*> slicerList; for(unsigned int volumeIdx=0; volumeIdx < om->volumes.size(); volumeIdx++) { slicerList.push_back(new Slicer(&om->volumes[volumeIdx], config.initialLayerThickness / 2, config.layerThickness, config.fixHorrible & FIX_HORRIBLE_KEEP_NONE_CLOSED, config.fixHorrible & FIX_HORRIBLE_EXTENSIVE_STITCHING)); //slicerList[volumeIdx]->dumpSegments("C:\\models\\output.html"); } log("Sliced model in %5.3fs\n", timeElapsed(t)); SliceDataStorage storage; if (config.supportAngle > -1) { fprintf(stdout,"Generating support map...\n"); generateSupportGrid(storage.support, om, config.initialLayerThickness / 2, config.layerThickness); } storage.modelSize = om->modelSize; storage.modelMin = om->vMin; storage.modelMax = om->vMax; delete om; log("Generating layer parts...\n"); for(unsigned int volumeIdx=0; volumeIdx < slicerList.size(); volumeIdx++) { storage.volumes.push_back(SliceVolumeStorage()); createLayerParts(storage.volumes[volumeIdx], slicerList[volumeIdx], config.fixHorrible & (FIX_HORRIBLE_UNION_ALL_TYPE_A | FIX_HORRIBLE_UNION_ALL_TYPE_B)); delete slicerList[volumeIdx]; } //carveMultipleVolumes(storage.volumes); generateMultipleVolumesOverlap(storage.volumes, config.multiVolumeOverlap); log("Generated layer parts in %5.3fs\n", timeElapsed(t)); //dumpLayerparts(storage, "c:/models/output.html"); const unsigned int totalLayers = storage.volumes[0].layers.size(); for(unsigned int layerNr=0; layerNr<totalLayers; layerNr++) { for(unsigned int volumeIdx=0; volumeIdx<storage.volumes.size(); volumeIdx++) { generateInsets(&storage.volumes[volumeIdx].layers[layerNr], config.extrusionWidth, config.insetCount); } logProgress("inset",layerNr+1,totalLayers); } log("Generated inset in %5.3fs\n", timeElapsed(t)); //dumpLayerparts(storage, "c:/models/output.html"); for(unsigned int layerNr=0; layerNr<totalLayers; layerNr++) { for(unsigned int volumeIdx=0; volumeIdx<storage.volumes.size(); volumeIdx++) { generateSkins(layerNr, storage.volumes[volumeIdx], config.extrusionWidth, config.downSkinCount, config.upSkinCount, config.infillOverlap); generateSparse(layerNr, storage.volumes[volumeIdx], config.extrusionWidth, config.downSkinCount, config.upSkinCount); } logProgress("skin",layerNr+1,totalLayers); } log("Generated up/down skin in %5.3fs\n", timeElapsed(t)); generateSkirt(storage, config.skirtDistance, config.extrusionWidth, config.skirtLineCount); generateRaft(storage, config.raftMargin); log("Generated skirt and raft in %5.3fs\n", timeElapsed(t)); for(unsigned int volumeIdx=0; volumeIdx<storage.volumes.size(); volumeIdx++) { for(unsigned int layerNr=0; layerNr<totalLayers; layerNr++) { for(unsigned int partNr=0; partNr<storage.volumes[volumeIdx].layers[layerNr].parts.size(); partNr++) { if (layerNr > 0) storage.volumes[volumeIdx].layers[layerNr].parts[partNr].bridgeAngle = bridgeAngle(&storage.volumes[volumeIdx].layers[layerNr].parts[partNr], &storage.volumes[volumeIdx].layers[layerNr-1]); else storage.volumes[volumeIdx].layers[layerNr].parts[partNr].bridgeAngle = -1; } } } log("Stored volumes in %5.3fs\n", timeElapsed(t)); gcode.setRetractionSettings(config.retractionAmount, config.retractionSpeed, config.retractionAmountExtruderSwitch); if (firstFile) { gcode.addCode(config.startCode); }else{ gcode.resetExtrusionValue(); gcode.addRetraction(); gcode.setZ(maxObjectHeight + 5000); gcode.addMove(config.objectPosition, config.moveSpeed, 0); } gcode.addComment("total_layers=%d",totalLayers); log("Added general info to gcode in %5.3fs\n", timeElapsed(t)); GCodePathConfig skirtConfig(config.printSpeed, config.extrusionWidth, "SKIRT"); GCodePathConfig inset0Config(config.printSpeed, config.extrusionWidth, "WALL-OUTER"); GCodePathConfig inset1Config(config.printSpeed, config.extrusionWidth, "WALL-INNER"); GCodePathConfig fillConfig(config.infillSpeed, config.extrusionWidth, "FILL"); GCodePathConfig supportConfig(config.printSpeed, config.supportLineWidth, "SUPPORT"); if (config.raftBaseThickness > 0 && config.raftInterfaceThickness > 0) { GCodePathConfig raftBaseConfig(config.initialLayerSpeed, config.raftBaseLinewidth, "SUPPORT"); GCodePathConfig raftInterfaceConfig(config.initialLayerSpeed, config.raftInterfaceLinewidth, "SUPPORT"); { gcode.addComment("LAYER:-2"); gcode.addComment("RAFT"); GCodePlanner gcodeLayer(gcode, config.moveSpeed); gcode.setZ(config.raftBaseThickness); gcode.setExtrusion(config.raftBaseThickness, config.filamentDiameter, config.filamentFlow); gcodeLayer.addPolygonsByOptimizer(storage.raftOutline, &raftBaseConfig); Polygons raftLines; generateLineInfill(storage.raftOutline, raftLines, config.raftBaseLinewidth, config.raftLineSpacing, config.infillOverlap, 0); gcodeLayer.addPolygonsByOptimizer(raftLines, &raftBaseConfig); gcodeLayer.writeGCode(false); } { gcode.addComment("LAYER:-1"); gcode.addComment("RAFT"); GCodePlanner gcodeLayer(gcode, config.moveSpeed); gcode.setZ(config.raftBaseThickness + config.raftInterfaceThickness); gcode.setExtrusion(config.raftInterfaceThickness, config.filamentDiameter, config.filamentFlow); Polygons raftLines; generateLineInfill(storage.raftOutline, raftLines, config.raftInterfaceLinewidth, config.raftLineSpacing, config.infillOverlap, 90); gcodeLayer.addPolygonsByOptimizer(raftLines, &raftInterfaceConfig); gcodeLayer.writeGCode(false); } } int volumeIdx = 0; for(unsigned int layerNr=0; layerNr<totalLayers; layerNr++) { logProgress("export", layerNr+1, totalLayers); log("Handling layer %u out of %u \n", layerNr+1, totalLayers); GCodePlanner gcodeLayer(gcode, config.moveSpeed); gcode.addComment("LAYER:%d", layerNr); int32_t z = config.initialLayerThickness + layerNr * config.layerThickness; z += config.raftBaseThickness + config.raftInterfaceThickness; gcode.setZ(z); //if (layerNr == 0) // gcodeLayer.addPolygonsByOptimizer(storage.skirt, &skirtConfig); //log("Mark1 in %5.3fs\n", timeElapsed(t)); for(unsigned int volumeCnt = 0; volumeCnt < storage.volumes.size(); volumeCnt++) { log(" Going through volume %u out of %u \n", volumeCnt+1, storage.volumes.size()); if (volumeCnt > 0) volumeIdx = (volumeIdx + 1) % storage.volumes.size(); SliceLayer* layer = &storage.volumes[volumeIdx].layers[layerNr]; gcodeLayer.setExtruder(volumeIdx); PathOptimizer partOrderOptimizer(gcode.getPositionXY()); for(unsigned int partNr=0; partNr<layer->parts.size(); partNr++) { partOrderOptimizer.addPolygon(layer->parts[partNr].insets[0][0]); } log("partOrderOptimizer polygons %u \n", partOrderOptimizer.polygons.size()); log("partOrderOptimizer polyorder %u \n", partOrderOptimizer.polyOrder.size()); partOrderOptimizer.optimize(); log("POST OPTIM partOrderOptimizer polygons %u \n", partOrderOptimizer.polygons.size()); log("POST OPTIM partOrderOptimizer polyorder %u \n", partOrderOptimizer.polyOrder.size()); //log("POST OPTIM polyorder at 0 %u \n", partOrderOptimizer.polyOrder[0]); log("toto\n"); for(unsigned int partCounter=0; partCounter<partOrderOptimizer.polyOrder.size(); partCounter++) { //log(" Going through part %u out of %u \n", partCounter+1, partOrderOptimizer.polyOrder.size()); SliceLayerPart* part = &layer->parts[partOrderOptimizer.polyOrder[partCounter]]; log("order index %u \n", partOrderOptimizer.polyOrder[partCounter]); try { if(part->skinOutline.size()>0) { if(part->skinOutline[0].size()>0) { Point p0 = (part->skinOutline)[0][0]; log("bla %f pof\n",p0.X); } } } catch (int e) { log("An exception occurred. Exception Nr.%i \n",e); } /*gcodeLayer.setCombBoundary(&part->combBoundery); gcodeLayer.forceRetract(); if (config.insetCount > 0) { for(int insetNr=part->insets.size()-1; insetNr>-1; insetNr--) { if (insetNr == 0) gcodeLayer.addPolygonsByOptimizer(part->insets[insetNr], &inset0Config); else gcodeLayer.addPolygonsByOptimizer(part->insets[insetNr], &inset1Config); } }*/ Polygons fillPolygons; int fillAngle = 45; if (layerNr & 1) fillAngle += 90; //int sparseSteps[1] = {config.extrusionWidth}; //generateConcentricInfill(part->skinOutline, fillPolygons, sparseSteps, 1); log("Passing skinOutline of size %u to generator\n", (part->skinOutline).size()); generateLineInfill(part->skinOutline, fillPolygons, config.extrusionWidth, config.extrusionWidth, config.infillOverlap, (part->bridgeAngle > -1) ? part->bridgeAngle : fillAngle); //int sparseSteps[2] = {config.extrusionWidth*5, config.extrusionWidth * 0.8}; //generateConcentricInfill(part->sparseOutline, fillPolygons, sparseSteps, 2); //log("Mark1-2: after infillLineGen\n"); if (config.sparseInfillLineDistance > 0) { if (config.sparseInfillLineDistance > config.extrusionWidth * 4) { generateLineInfill(part->sparseOutline, fillPolygons, config.extrusionWidth, config.sparseInfillLineDistance * 2, config.infillOverlap, 45); generateLineInfill(part->sparseOutline, fillPolygons, config.extrusionWidth, config.sparseInfillLineDistance * 2, config.infillOverlap, 45 + 90); } else { generateLineInfill(part->sparseOutline, fillPolygons, config.extrusionWidth, config.sparseInfillLineDistance, config.infillOverlap, fillAngle); } } //log("Mark1-3: after before adding polygons\n"); gcodeLayer.addPolygonsByOptimizer(fillPolygons, &fillConfig); } gcodeLayer.setCombBoundary(NULL); } //log("Mark2: before supportAngle\n"); if (config.supportAngle > -1) { SupportPolyGenerator supportGenerator(storage.support, z, config.supportAngle, config.supportEverywhere > 0, true); gcodeLayer.addPolygonsByOptimizer(supportGenerator.polygons, &supportConfig); if (layerNr == 0) { SupportPolyGenerator supportGenerator2(storage.support, z, config.supportAngle, config.supportEverywhere > 0, false); gcodeLayer.addPolygonsByOptimizer(supportGenerator2.polygons, &supportConfig); } } //log("Mark2: before speedup\n"); //Finish the layer by applying speed corrections for minimal layer times and slowdown for the initial layer. if (int(layerNr) < config.initialSpeedupLayers) { int n = config.initialSpeedupLayers; int layer0Factor = config.initialLayerSpeed * 100 / config.printSpeed; gcodeLayer.setSpeedFactor((layer0Factor * (n - layerNr) + 100 * (layerNr)) / n); } gcodeLayer.forceMinimalLayerTime(config.minimalLayerTime, config.minimalFeedrate); if (layerNr == 0) gcode.setExtrusion(config.initialLayerThickness, config.filamentDiameter, config.filamentFlow); else gcode.setExtrusion(config.layerThickness, config.filamentDiameter, config.filamentFlow); //log("Mark3: before fan on\n"); if (int(layerNr) >= config.fanOnLayerNr) { int speed = config.fanSpeedMin; if (gcodeLayer.getSpeedFactor() <= 50) { speed = config.fanSpeedMax; }else{ int n = gcodeLayer.getSpeedFactor() - 50; speed = config.fanSpeedMin * n / 50 + config.fanSpeedMax * (50 - n) / 50; } gcode.addFanCommand(speed); }else{ gcode.addFanCommand(0); } //log("Finished layer in %5.3fs\n", timeElapsed(t)); gcodeLayer.writeGCode(config.coolHeadLift > 0); //log("Finished writing layer in %5.3fs\n", timeElapsed(t)); } /* support debug for(int32_t y=0; y<storage.support.gridHeight; y++) { for(int32_t x=0; x<storage.support.gridWidth; x++) { unsigned int n = x+y*storage.support.gridWidth; if (storage.support.grid[n].size() < 1) continue; int32_t z = storage.support.grid[n][0].z; gcode.addMove(Point3(x * storage.support.gridScale + storage.support.gridOffset.X, y * storage.support.gridScale + storage.support.gridOffset.Y, 0), 0); gcode.addMove(Point3(x * storage.support.gridScale + storage.support.gridOffset.X, y * storage.support.gridScale + storage.support.gridOffset.Y, z), z); gcode.addMove(Point3(x * storage.support.gridScale + storage.support.gridOffset.X, y * storage.support.gridScale + storage.support.gridOffset.Y, 0), 0); } } //*/ log("Wrote layers in %5.2fs.\n", timeElapsed(t)); gcode.tellFileSize(); gcode.addFanCommand(0); logProgress("process", 1, 1); log("Total time elapsed %5.2fs.\n", timeElapsed(t,true)); //Store the object height for when we are printing multiple objects, as we need to clear every one of them when moving to the next position. maxObjectHeight = std::max(maxObjectHeight, storage.modelSize.z); }
void processFile(const char* input_filename, ConfigSettings& config, GCodeExport& gcode, bool firstFile) { for(unsigned int n=1; n<16;n++) gcode.setExtruderOffset(n, config.extruderOffset[n].p()); gcode.setFlavor(config.gcodeFlavor); double t = getTime(); log("Loading %s from disk...\n", input_filename); SimpleModel* m = loadModel(input_filename, config.matrix); if (!m) { log("Failed to load model: %s\n", input_filename); return; } log("Loaded from disk in %5.3fs\n", timeElapsed(t)); log("Analyzing and optimizing model...\n"); OptimizedModel* om = new OptimizedModel(m, Point3(config.objectPosition.X, config.objectPosition.Y, -config.objectSink)); for(unsigned int v = 0; v < m->volumes.size(); v++) { log(" Face counts: %i -> %i %0.1f%%\n", (int)m->volumes[v].faces.size(), (int)om->volumes[v].faces.size(), float(om->volumes[v].faces.size()) / float(m->volumes[v].faces.size()) * 100); log(" Vertex counts: %i -> %i %0.1f%%\n", (int)m->volumes[v].faces.size() * 3, (int)om->volumes[v].points.size(), float(om->volumes[v].points.size()) / float(m->volumes[v].faces.size() * 3) * 100); } delete m; log("Optimize model %5.3fs \n", timeElapsed(t)); //om->saveDebugSTL("c:\\models\\output.stl"); log("Slicing model...\n"); vector<Slicer*> slicerList; for(unsigned int volumeIdx=0; volumeIdx < om->volumes.size(); volumeIdx++) { slicerList.push_back(new Slicer(&om->volumes[volumeIdx], config.initialLayerThickness / 2, config.layerThickness, config.fixHorrible & FIX_HORRIBLE_KEEP_NONE_CLOSED, config.fixHorrible & FIX_HORRIBLE_EXTENSIVE_STITCHING)); //slicerList[volumeIdx]->dumpSegments("C:\\models\\output.html"); } log("Sliced model in %5.3fs\n", timeElapsed(t)); SliceDataStorage storage; if (config.supportAngle > -1) { fprintf(stdout,"Generating support map...\n"); generateSupportGrid(storage.support, om); } storage.modelSize = om->modelSize; storage.modelMin = om->vMin; storage.modelMax = om->vMax; delete om; log("Generating layer parts...\n"); for(unsigned int volumeIdx=0; volumeIdx < slicerList.size(); volumeIdx++) { storage.volumes.push_back(SliceVolumeStorage()); createLayerParts(storage.volumes[volumeIdx], slicerList[volumeIdx], config.fixHorrible & (FIX_HORRIBLE_UNION_ALL_TYPE_A | FIX_HORRIBLE_UNION_ALL_TYPE_B)); delete slicerList[volumeIdx]; } //carveMultipleVolumes(storage.volumes); generateMultipleVolumesOverlap(storage.volumes, config.multiVolumeOverlap); log("Generated layer parts in %5.3fs\n", timeElapsed(t)); //dumpLayerparts(storage, "c:/models/output.html"); const unsigned int totalLayers = storage.volumes[0].layers.size(); for(unsigned int layerNr=0; layerNr<totalLayers; layerNr++) { for(unsigned int volumeIdx=0; volumeIdx<storage.volumes.size(); volumeIdx++) { generateInsets(&storage.volumes[volumeIdx].layers[layerNr], config.extrusionWidth, config.insetCount); } logProgress("inset",layerNr+1,totalLayers); } log("Generated inset in %5.3fs\n", timeElapsed(t)); //dumpLayerparts(storage, "c:/models/output.html"); for(unsigned int layerNr=0; layerNr<totalLayers; layerNr++) { for(unsigned int volumeIdx=0; volumeIdx<storage.volumes.size(); volumeIdx++) { generateSkins(layerNr, storage.volumes[volumeIdx], config.extrusionWidth, config.downSkinCount, config.upSkinCount, config.infillOverlap); generateSparse(layerNr, storage.volumes[volumeIdx], config.extrusionWidth, config.downSkinCount, config.upSkinCount); } logProgress("skin",layerNr+1,totalLayers); } log("Generated up/down skin in %5.3fs\n", timeElapsed(t)); generateSkirt(storage, config.skirtDistance, config.extrusionWidth, config.skirtLineCount, config.skirtMinLength); generateRaft(storage, config.raftMargin, config.supportAngle, config.supportEverywhere > 0, config.supportXYDistance); for(unsigned int volumeIdx=0; volumeIdx<storage.volumes.size(); volumeIdx++) { for(unsigned int layerNr=0; layerNr<totalLayers; layerNr++) { for(unsigned int partNr=0; partNr<storage.volumes[volumeIdx].layers[layerNr].parts.size(); partNr++) { if (layerNr > 0) storage.volumes[volumeIdx].layers[layerNr].parts[partNr].bridgeAngle = bridgeAngle(&storage.volumes[volumeIdx].layers[layerNr].parts[partNr], &storage.volumes[volumeIdx].layers[layerNr-1]); else storage.volumes[volumeIdx].layers[layerNr].parts[partNr].bridgeAngle = -1; } } } gcode.setRetractionSettings(config.retractionAmount, config.retractionSpeed, config.retractionAmountExtruderSwitch, config.minimalExtrusionBeforeRetraction); if (firstFile) { if (gcode.getFlavor() == GCODE_FLAVOR_ULTIGCODE) { gcode.addCode(";FLAVOR:UltiGCode"); gcode.addCode(";TIME:<__TIME__>"); gcode.addCode(";MATERIAL:<FILAMENT>"); } gcode.addCode(config.startCode); }else{ gcode.addFanCommand(0); gcode.resetExtrusionValue(); gcode.addRetraction(); gcode.setZ(maxObjectHeight + 5000); gcode.addMove(Point(storage.modelMin.x, storage.modelMin.y), config.moveSpeed, 0); } gcode.addComment("total_layers=%d",totalLayers); GCodePathConfig skirtConfig(config.printSpeed, config.extrusionWidth, "SKIRT"); GCodePathConfig inset0Config(config.printSpeed, config.extrusionWidth, "WALL-OUTER"); GCodePathConfig inset1Config(config.printSpeed, config.extrusionWidth, "WALL-INNER"); GCodePathConfig fillConfig(config.infillSpeed, config.extrusionWidth, "FILL"); GCodePathConfig supportConfig(config.printSpeed, config.extrusionWidth, "SUPPORT"); if (config.raftBaseThickness > 0 && config.raftInterfaceThickness > 0) { GCodePathConfig raftBaseConfig(config.initialLayerSpeed, config.raftBaseLinewidth, "SUPPORT"); GCodePathConfig raftInterfaceConfig(config.initialLayerSpeed, config.raftInterfaceLinewidth, "SUPPORT"); { gcode.addComment("LAYER:-2"); gcode.addComment("RAFT"); GCodePlanner gcodeLayer(gcode, config.moveSpeed, config.retractionMinimalDistance); gcode.setZ(config.raftBaseThickness); gcode.setExtrusion(config.raftBaseThickness, config.filamentDiameter, config.filamentFlow); gcodeLayer.addPolygonsByOptimizer(storage.raftOutline, &raftBaseConfig); Polygons raftLines; generateLineInfill(storage.raftOutline, raftLines, config.raftBaseLinewidth, config.raftLineSpacing, config.infillOverlap, 0); gcodeLayer.addPolygonsByOptimizer(raftLines, &raftBaseConfig); gcodeLayer.writeGCode(false); } { gcode.addComment("LAYER:-1"); gcode.addComment("RAFT"); GCodePlanner gcodeLayer(gcode, config.moveSpeed, config.retractionMinimalDistance); gcode.setZ(config.raftBaseThickness + config.raftInterfaceThickness); gcode.setExtrusion(config.raftInterfaceThickness, config.filamentDiameter, config.filamentFlow); Polygons raftLines; generateLineInfill(storage.raftOutline, raftLines, config.raftInterfaceLinewidth, config.raftLineSpacing, config.infillOverlap, 90); gcodeLayer.addPolygonsByOptimizer(raftLines, &raftInterfaceConfig); gcodeLayer.writeGCode(false); } } int volumeIdx = 0; for(unsigned int layerNr=0; layerNr<totalLayers; layerNr++) { logProgress("export", layerNr+1, totalLayers); GCodePlanner gcodeLayer(gcode, config.moveSpeed, config.retractionMinimalDistance); gcode.addComment("LAYER:%d", layerNr); int32_t z = config.initialLayerThickness + layerNr * config.layerThickness; z += config.raftBaseThickness + config.raftInterfaceThickness; gcode.setZ(z); if (layerNr == 0) gcodeLayer.addPolygonsByOptimizer(storage.skirt, &skirtConfig); for(unsigned int volumeCnt = 0; volumeCnt < storage.volumes.size(); volumeCnt++) { if (volumeCnt > 0) volumeIdx = (volumeIdx + 1) % storage.volumes.size(); SliceLayer* layer = &storage.volumes[volumeIdx].layers[layerNr]; gcodeLayer.setExtruder(volumeIdx); PathOptimizer partOrderOptimizer(gcode.getPositionXY()); for(unsigned int partNr=0; partNr<layer->parts.size(); partNr++) { partOrderOptimizer.addPolygon(layer->parts[partNr].insets[0][0]); } partOrderOptimizer.optimize(); for(unsigned int partCounter=0; partCounter<partOrderOptimizer.polyOrder.size(); partCounter++) { SliceLayerPart* part = &layer->parts[partOrderOptimizer.polyOrder[partCounter]]; if (config.enableCombing) gcodeLayer.setCombBoundary(&part->combBoundery); else gcodeLayer.setAlwaysRetract(true); gcodeLayer.forceRetract(); if (config.insetCount > 0) { for(int insetNr=part->insets.size()-1; insetNr>-1; insetNr--) { if (insetNr == 0) gcodeLayer.addPolygonsByOptimizer(part->insets[insetNr], &inset0Config); else gcodeLayer.addPolygonsByOptimizer(part->insets[insetNr], &inset1Config); } } Polygons fillPolygons; int fillAngle = 45; if (layerNr & 1) fillAngle += 90; //int sparseSteps[1] = {config.extrusionWidth}; //generateConcentricInfill(part->skinOutline, fillPolygons, sparseSteps, 1); generateLineInfill(part->skinOutline, fillPolygons, config.extrusionWidth, config.extrusionWidth, config.infillOverlap, (part->bridgeAngle > -1) ? part->bridgeAngle : fillAngle); //int sparseSteps[2] = {config.extrusionWidth*5, config.extrusionWidth * 0.8}; //generateConcentricInfill(part->sparseOutline, fillPolygons, sparseSteps, 2); if (config.sparseInfillLineDistance > 0) { if (config.sparseInfillLineDistance > config.extrusionWidth * 4) { generateLineInfill(part->sparseOutline, fillPolygons, config.extrusionWidth, config.sparseInfillLineDistance * 2, config.infillOverlap, 45); generateLineInfill(part->sparseOutline, fillPolygons, config.extrusionWidth, config.sparseInfillLineDistance * 2, config.infillOverlap, 45 + 90); } else { generateLineInfill(part->sparseOutline, fillPolygons, config.extrusionWidth, config.sparseInfillLineDistance, config.infillOverlap, fillAngle); } } gcodeLayer.addPolygonsByOptimizer(fillPolygons, &fillConfig); //After a layer part, make sure the nozzle is inside the comb boundary, so we do not retract on the perimeter. gcodeLayer.moveInsideCombBoundary(); } gcodeLayer.setCombBoundary(NULL); } if (config.supportAngle > -1) { if (config.supportExtruder > -1) gcodeLayer.setExtruder(config.supportExtruder); SupportPolyGenerator supportGenerator(storage.support, z, config.supportAngle, config.supportEverywhere > 0, config.supportXYDistance, config.supportZDistance); ClipperLib::Clipper supportClipper; supportClipper.AddPolygons(supportGenerator.polygons, ClipperLib::ptSubject); for(unsigned int volumeCnt = 0; volumeCnt < storage.volumes.size(); volumeCnt++) { SliceLayer* layer = &storage.volumes[volumeIdx].layers[layerNr]; Polygons polys; for(unsigned int n=0; n<layer->parts.size(); n++) for(unsigned int m=0; m<layer->parts[n].outline.size(); m++) polys.push_back(layer->parts[n].outline[m]); ClipperLib::OffsetPolygons(polys, polys, config.supportXYDistance, ClipperLib::jtSquare, 2, false); supportClipper.AddPolygons(polys, ClipperLib::ptClip); } supportClipper.Execute(ClipperLib::ctDifference, supportGenerator.polygons); Polygons supportLines; if (config.supportLineDistance > 0) { if (config.supportLineDistance > config.extrusionWidth * 4) { generateLineInfill(supportGenerator.polygons, supportLines, config.extrusionWidth, config.supportLineDistance*2, config.infillOverlap, 0); generateLineInfill(supportGenerator.polygons, supportLines, config.extrusionWidth, config.supportLineDistance*2, config.infillOverlap, 90); }else{ generateLineInfill(supportGenerator.polygons, supportLines, config.extrusionWidth, config.supportLineDistance, config.infillOverlap, (layerNr & 1) ? 0 : 90); } } gcodeLayer.addPolygonsByOptimizer(supportGenerator.polygons, &supportConfig); gcodeLayer.addPolygonsByOptimizer(supportLines, &supportConfig); } //Finish the layer by applying speed corrections for minimal layer times and slowdown for the initial layer. if (int(layerNr) < config.initialSpeedupLayers) { int n = config.initialSpeedupLayers; int layer0Factor = config.initialLayerSpeed * 100 / config.printSpeed; gcodeLayer.setExtrudeSpeedFactor((layer0Factor * (n - layerNr) + 100 * (layerNr)) / n); } gcodeLayer.forceMinimalLayerTime(config.minimalLayerTime, config.minimalFeedrate); if (layerNr == 0) gcode.setExtrusion(config.initialLayerThickness, config.filamentDiameter, config.filamentFlow); else gcode.setExtrusion(config.layerThickness, config.filamentDiameter, config.filamentFlow); if (int(layerNr) >= config.fanOnLayerNr) { int speed = config.fanSpeedMin; if (gcodeLayer.getExtrudeSpeedFactor() <= 50) { speed = config.fanSpeedMax; }else{ int n = gcodeLayer.getExtrudeSpeedFactor() - 50; speed = config.fanSpeedMin * n / 50 + config.fanSpeedMax * (50 - n) / 50; } gcode.addFanCommand(speed); }else{ gcode.addFanCommand(0); } gcodeLayer.writeGCode(config.coolHeadLift > 0); } /* support debug for(int32_t y=0; y<storage.support.gridHeight; y++) { for(int32_t x=0; x<storage.support.gridWidth; x++) { unsigned int n = x+y*storage.support.gridWidth; if (storage.support.grid[n].size() < 1) continue; int32_t z = storage.support.grid[n][0].z; gcode.addMove(Point3(x * storage.support.gridScale + storage.support.gridOffset.X, y * storage.support.gridScale + storage.support.gridOffset.Y, 0), 0); gcode.addMove(Point3(x * storage.support.gridScale + storage.support.gridOffset.X, y * storage.support.gridScale + storage.support.gridOffset.Y, z), z); gcode.addMove(Point3(x * storage.support.gridScale + storage.support.gridOffset.X, y * storage.support.gridScale + storage.support.gridOffset.Y, 0), 0); } } //*/ log("Wrote layers in %5.2fs.\n", timeElapsed(t)); gcode.tellFileSize(); gcode.addFanCommand(0); logProgress("process", 1, 1); log("Total time elapsed %5.2fs.\n", timeElapsed(t,true)); //Store the object height for when we are printing multiple objects, as we need to clear every one of them when moving to the next position. maxObjectHeight = std::max(maxObjectHeight, storage.modelSize.z); }
const char* testClient(void* parameters) { struct workerTask* worker = (struct workerTask*)parameters; uint16_t randContext[3]; for(int i = 0; i < 3; i++) { randContext[i] = time(NULL) ^ worker->workerID; } if(!worker->conn) { //spread the load from new connections so the server won't be overloaded usleep(erand48(randContext) * 1000 + 1000*worker->connOpenDelay); worker->conn = storage_connect(worker->hostname, worker->port); if(!worker->conn) { printf("storage_connect failed\n"); return ece297strerror(errno); } int result = storage_auth(worker->username, worker->password, worker->conn); if(result == -1) { printf("storage_auth failed\n"); storage_disconnect(worker->conn); worker->conn = NULL; return ece297strerror(errno); } } uint64_t loopCount = worker->numKeys; if(worker->type == kClientRunWorkload) { loopCount = worker->count; } uint64_t period = 0; //0 throughput = no limit if(worker->throughput) { period = (1/worker->throughput) * 1000000; //start at a random time usleep(erand48(randContext) * period); } struct timeval next; gettimeofday(&next, NULL); for(uint64_t i = 0; i < loopCount; i++) { if(worker->throughput) { int64_t timeRemaining = -uSElapsed(&next); if(timeRemaining > 0) { usleep((uint32_t)timeRemaining); } uint64_t newTime = next.tv_usec + period; next.tv_sec += newTime / 1000000; next.tv_usec = newTime % 1000000; } switch (worker->type) { case kClientAddKeys: { char keyBuf[20]; //as per ECE297 spec stringGen(worker->startingKey + i, worker->keySecret, keyBuf, sizeof(keyBuf)); struct storage_record record; memset(&record.metadata, 0, sizeof(record.metadata)); stringGen(worker->startingKey + i, worker->valueSecret, record.value, sizeof(record.value)); struct timeval start; gettimeofday(&start, NULL); if(storage_set(worker->table, keyBuf, &record, worker->conn) == -1) { printf("storage_set failed\n"); return ece297strerror(errno); } recordLatency(timeElapsed(&start), worker->latencyResults); break; } case kClientRunWorkload: { //WATCH the floating point promotion - it must be cast to a uint64_t BEFORE adding worker->startingKey uint64_t keyIndex = ((uint64_t)(erand48(randContext) * worker->numKeys)) + worker->startingKey; char keyBuf[20]; //as per ECE297 spec stringGen(keyIndex, worker->keySecret, keyBuf, sizeof(keyBuf)); char expectedValue[1024]; stringGen(keyIndex, worker->valueSecret, expectedValue, sizeof(expectedValue)); struct timeval start; gettimeofday(&start, NULL); struct storage_record rec; if(storage_get(worker->table, keyBuf, &rec, worker->conn) == -1) { printf("storage_get failed (key index = %u)\n", keyIndex); return ece297strerror(errno); } if(strcmp(rec.value, expectedValue)) { return "Server returned incorrect key"; } recordLatency(timeElapsed(&start), worker->latencyResults); } } } return NULL; }
json_t* readCommand(int fd, int timeout) { struct timeval start; gettimeofday(&start, NULL); uint32_t expectedSize = 0; char buf[4096]; while(1) { char sizeBuf[9]; ssize_t result = recv(fd, sizeBuf, sizeof(sizeBuf) - 1, MSG_DONTWAIT); if(result == -1 && !(errno == EAGAIN || errno == EWOULDBLOCK)) { perror("recv failed"); return NULL; } if(result == 0) { fprintf(stderr, "Remote hung up unexpectedly\n"); return NULL; } if(result == (sizeof(sizeBuf) - 1)) { sizeBuf[8] = '\0'; expectedSize = atoi(sizeBuf); if(expectedSize > (sizeof(buf) -1) || expectedSize == 0) { fprintf(stderr, "Packet with incorrect size recived (%d)\n", expectedSize); return NULL; } break; } if(timeElapsed(&start) < timeout * 10) { usleep(1000); continue; } return NULL; } uint32_t amountRead = 0; while(amountRead < expectedSize) { ssize_t result = recv(fd, buf + amountRead, expectedSize - amountRead, MSG_DONTWAIT); if(result == -1 && !(errno == EAGAIN || errno == EWOULDBLOCK)) { perror("recv failed"); return NULL; } if(result == 0) { fprintf(stderr, "Remote hung up unexpectedly\n"); return NULL; } if(result > 0) { amountRead += result; } else { if(timeElapsed(&start) < timeout * 10) { usleep(10000); continue; } return NULL; } } buf[expectedSize] = '\0'; json_error_t err; json_t* root = json_loads(buf, 0, &err); if(!root) { fprintf(stderr, "Error parsing JSON on Line %d: %s\n", err.line, err.text); } return root; }
void reverse(){ reverse( timeElapsed(), 0.f, AnimationFunc ); }
//void SimulationEngine::update( opal::real& elapsedSimTime, //opal::real& elapsedRealTime) void SimulationEngine::update(void) { opal::real elapsedSimTime; opal::real elapsedRealTime; #ifndef SIMULATION_ENGINE_PHYSICS_ONLY //if (mOgreWindow->isClosed()) //{ //mQuitApp = true; //return; //} #endif // Get the elapsed time in seconds since the last time we were here. //elapsedRealTime = mFrameTimer.getTimeMilliseconds() * (opal::real)0.001; //mFrameTimer.reset(); elapsedRealTime = (opal::real)timeElapsed(); elapsedSimTime = elapsedRealTime; #ifndef SIMULATION_ENGINE_PHYSICS_ONLY //if (false == handleInput(elapsedRealTime)) //{ //mQuitApp = true; //return; //} #endif //if (!mPaused) //{ switch(mUpdateMode) { case SIMULATE_CONSTANT_CHUNK: // Simulate constant chunks of time at once. Keep in // mind that this must finish before continuing, so // if it takes a while to simulate a single chunk // of time, the input handling might become unresponsive. elapsedSimTime = mUpdateConstant; break; case SIMULATE_REAL_TIME_MULTIPLE: elapsedSimTime *= mUpdateConstant; break; default: assert(false); break; } //mSimulator->simulate(elapsedSimTime); mSimulator->simulate(0.01); size_t size = mPhysicalEntityList.size(); for(size_t i = 0; i<size; ++i) { //mPhysicalEntityList.at(i)->update(elapsedSimTime); mPhysicalEntityList.at(i)->update(0.01); } #ifndef SIMULATION_ENGINE_PHYSICS_ONLY //mPhysicalCamera->update(elapsedSimTime); #endif //} #ifndef SIMULATION_ENGINE_PHYSICS_ONLY //updatePickingGraphics(); // 'renderOneFrame' returns a bool that determines whether we should // quit, but it is only useful when using pre and post frame event // listeners. //mOgreRoot->renderOneFrame(); // Update the stats overlay. //updateOgreStats(); //if (mCaptureFramesEnabled) //{ // captureFrame(); //} #endif }
float Stopwatch::secondsElapsed() { timeval elapsed = timeElapsed(); return elapsed.tv_sec + elapsed.tv_usec / (float)US_PER_SEC; }