/*
* 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;
}
