GitHub-Proxy/PrusaSlicer
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/prusa3d/PrusaSlicer.git synced 2025-08-14 05:45:57 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactored parallelization code

Browse Source
This commit is contained in:
Alessandro Ranellucci 2016-11-26 16:07:36 +01:00
parent dabb7cb2ee
commit 3678977447
6 changed files with 107 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
xs/src/libslic3r/Print.hpp
View File

@ -2,7 +2,6 @@
#define slic3r_Print_hpp_
#include "libslic3r.h"
#include <queue>
#include <set>
#include <string>
#include <vector>
@ -148,8 +147,6 @@ class PrintObject
// parameter
PrintObject(Print* print, ModelObject* model_object, const BoundingBoxf3 &modobj_bbox);
~PrintObject();
void _make_perimeters_do(std::queue<size_t>* queue, boost::mutex* queue_mutex);
void _infill_do(std::queue<size_t>* queue, boost::mutex* queue_mutex);
};
typedef std::vector<PrintObject*> PrintObjectPtrs;

2
xs/src/libslic3r/PrintConfig.cpp
View File

@ -1248,7 +1248,7 @@ PrintConfigDef::PrintConfigDef()
def->readonly = true;
def->min = 1;
def->max = 16;
def->default_value = new ConfigOptionInt(boost::thread::hardware_concurrency());
def->default_value = new ConfigOptionInt(boost::thread::hardware_concurrency() || 2);
def = this->add("toolchange_gcode", coString);
def->label = "Tool change G-code";

72
xs/src/libslic3r/PrintObject.cpp
View File

@ -584,18 +584,11 @@ PrintObject::_make_perimeters()
}
}
{
// queue all the layer numbers
std::queue<size_t> queue;
boost::mutex queue_mutex;
for (size_t i = 0; i < this->layer_count(); ++i)
queue.push(i);
boost::thread_group workers;
for (int i = 0; i < this->_print->config.threads; i++)
workers.add_thread(new boost::thread(&Slic3r::PrintObject::_make_perimeters_do, this, &queue, &queue_mutex));
workers.join_all();
}
parallelize<Layer*>(
std::queue<Layer*>(std::deque<Layer*>(this->layers.begin(), this->layers.end())), // cast LayerPtrs to std::queue<Layer*>
boost::bind(&Slic3r::Layer::make_perimeters, _1),
this->_print->config.threads.value
);
/*
simplify slices (both layer and region slices),
@ -607,43 +600,17 @@ PrintObject::_make_perimeters()
this->state.set_done(posPerimeters);
}
void
PrintObject::_make_perimeters_do(std::queue<size_t>* queue, boost::mutex* queue_mutex)
{
//std::cout << "THREAD STARTED: " << boost::this_thread::get_id() << std::endl;
while (true) {
size_t layer_id;
{
boost::lock_guard<boost::mutex> l(*queue_mutex);
if (queue->empty()) return;
layer_id = queue->front();
queue->pop();
}
//std::cout << " Layer " << layer_id << " (" << boost::this_thread::get_id() << ")" << std::endl;
this->get_layer(layer_id)->make_perimeters();
boost::this_thread::interruption_point();
}
}
void
PrintObject::_infill()
{
if (this->state.is_done(posInfill)) return;
this->state.set_started(posInfill);
{
// queue all the layer numbers
std::queue<size_t> queue;
boost::mutex queue_mutex;
for (size_t i = 0; i < this->layer_count(); ++i)
queue.push(i);
boost::thread_group workers;
for (int i = 0; i < this->_print->config.threads; i++)
workers.add_thread(new boost::thread(&Slic3r::PrintObject::_infill_do, this, &queue, &queue_mutex));
workers.join_all();
}
parallelize<Layer*>(
std::queue<Layer*>(std::deque<Layer*>(this->layers.begin(), this->layers.end())), // cast LayerPtrs to std::queue<Layer*>
boost::bind(&Slic3r::Layer::make_fills, _1),
this->_print->config.threads.value
);
/* we could free memory now, but this would make this step not idempotent
### $_->fill_surfaces->clear for map @{$_->regions}, @{$object->layers};
@ -652,23 +619,4 @@ PrintObject::_infill()
this->state.set_done(posInfill);
}
void
PrintObject::_infill_do(std::queue<size_t>* queue, boost::mutex* queue_mutex)
{
//std::cout << "THREAD STARTED: " << boost::this_thread::get_id() << std::endl;
while (true) {
size_t layer_id;
{
boost::lock_guard<boost::mutex> l(*queue_mutex);
if (queue->empty()) return;
layer_id = queue->front();
queue->pop();
}
//std::cout << " Layer " << layer_id << " (" << boost::this_thread::get_id() << ")" << std::endl;
this->get_layer(layer_id)->make_fills();
boost::this_thread::interruption_point();
}
}
}

74
xs/src/libslic3r/TriangleMesh.cpp
View File

@ -3,6 +3,7 @@
#include "Geometry.hpp"
#include <cmath>
#include <deque>
#include <queue>
#include <set>
#include <vector>
#include <map>
@ -456,56 +457,30 @@ TriangleMeshSlicer::slice(const std::vector<float> &z, std::vector<Polygons>* la
*/
std::vector<IntersectionLines> lines(z.size());
{
// queue all the facet indices
std::queue<size_t> queue;
boost::mutex queue_mutex, lines_mutex;
for (size_t i = 0; i < this->mesh->stl.stats.number_of_facets; ++i) queue.push(i);
boost::thread_group workers;
for (int i = 0; i < boost::thread::hardware_concurrency(); i++)
workers.add_thread(new boost::thread(&TriangleMeshSlicer::_slice_do, this,
&queue, &queue_mutex, &lines, &lines_mutex, z));
workers.join_all();
boost::mutex lines_mutex;
parallelize<int>(
0,
this->mesh->stl.stats.number_of_facets-1,
boost::bind(&TriangleMeshSlicer::_slice_do, this, _1, &lines, &lines_mutex, z)
);
}
// v_scaled_shared could be freed here
// build loops
layers->resize(z.size());
{
// queue all the layer numbers
std::queue<size_t> queue;
boost::mutex queue_mutex;
for (size_t i = 0; i < lines.size(); ++i) queue.push(i);
// We don't use a mutex for lines because workers are only writing the skip property
// and no workers work on the same layer (i.e. item of 'lines').
boost::thread_group workers;
for (int i = 0; i < boost::thread::hardware_concurrency(); i++)
workers.add_thread(new boost::thread(&TriangleMeshSlicer::_make_loops_do, this,
&queue, &queue_mutex, &lines, layers));
workers.join_all();
}
parallelize<size_t>(
0,
lines.size()-1,
boost::bind(&TriangleMeshSlicer::_make_loops_do, this, _1, &lines, layers)
);
}
void
TriangleMeshSlicer::_slice_do(std::queue<size_t>* queue, boost::mutex* queue_mutex,
std::vector<IntersectionLines>* lines, boost::mutex* lines_mutex, const std::vector<float> &z) const
TriangleMeshSlicer::_slice_do(size_t facet_idx, std::vector<IntersectionLines>* lines, boost::mutex* lines_mutex,
const std::vector<float> &z) const
{
//std::cout << "THREAD STARTED: " << boost::this_thread::get_id() << std::endl;
while (true) {
int facet_idx;
{
boost::lock_guard<boost::mutex> l(*queue_mutex);
if (queue->empty()) return;
facet_idx = queue->front();
queue->pop();
}
//std::cout << " Facet " << facet_idx << " (" << boost::this_thread::get_id() << ")" << std::endl;
const stl_facet &facet = this->mesh->stl.facet_start[facet_idx];
// find facet extents
@ -532,9 +507,6 @@ TriangleMeshSlicer::_slice_do(std::queue<size_t>* queue, boost::mutex* queue_mut
std::vector<float>::size_type layer_idx = it - z.begin();
this->slice_facet(*it / SCALING_FACTOR, facet, facet_idx, min_z, max_z, &(*lines)[layer_idx], lines_mutex);
}
boost::this_thread::interruption_point();
}
}
void
@ -678,23 +650,9 @@ TriangleMeshSlicer::slice_facet(float slice_z, const stl_facet &facet, const int
}
void
TriangleMeshSlicer::_make_loops_do(std::queue<size_t>* queue, boost::mutex* queue_mutex,
std::vector<IntersectionLines>* lines, std::vector<Polygons>* layers) const
TriangleMeshSlicer::_make_loops_do(size_t i, std::vector<IntersectionLines>* lines, std::vector<Polygons>* layers) const
{
//std::cout << "THREAD STARTED: " << boost::this_thread::get_id() << std::endl;
while (true) {
size_t layer_id;
{
boost::lock_guard<boost::mutex> l(*queue_mutex);
if (queue->empty()) return;
layer_id = queue->front();
queue->pop();
}
//std::cout << " Layer " << layer_id << " (" << boost::this_thread::get_id() << ")" << std::endl;
this->make_loops((*lines)[layer_id], &(*layers)[layer_id]);
boost::this_thread::interruption_point();
}
this->make_loops((*lines)[i], &(*layers)[i]);
}
void

7
xs/src/libslic3r/TriangleMesh.hpp
View File

@ -3,7 +3,6 @@
#include "libslic3r.h"
#include <admesh/stl.h>
#include <queue>
#include <vector>
#include <boost/thread.hpp>
#include "BoundingBox.hpp"
@ -105,10 +104,8 @@ class TriangleMeshSlicer
typedef std::vector< std::vector<int> > t_facets_edges;
t_facets_edges facets_edges;
stl_vertex* v_scaled_shared;
void _slice_do(std::queue<size_t>* queue, boost::mutex* queue_mutex,
std::vector<IntersectionLines>* lines, boost::mutex* lines_mutex, const std::vector<float> &z) const;
void _make_loops_do(std::queue<size_t>* queue, boost::mutex* queue_mutex,
std::vector<IntersectionLines>* lines, std::vector<Polygons>* layers) const;
void _slice_do(size_t facet_idx, std::vector<IntersectionLines>* lines, boost::mutex* lines_mutex, const std::vector<float> &z) const;
void _make_loops_do(size_t i, std::vector<IntersectionLines>* lines, std::vector<Polygons>* layers) const;
void make_loops(std::vector<IntersectionLine> &lines, Polygons* loops) const;
void make_expolygons(const Polygons &loops, ExPolygons* slices) const;
void make_expolygons_simple(std::vector<IntersectionLine> &lines, ExPolygons* slices) const;

67
xs/src/libslic3r/libslic3r.h
View File

@ -4,8 +4,10 @@
// this needs to be included early for MSVC (listing it in Build.PL is not enough)
#include <ostream>
#include <iostream>
#include <queue>
#include <sstream>
#include <vector>
#include <boost/thread.hpp>
#define SLIC3R_VERSION "1.3.0-dev"
@ -34,19 +36,6 @@
typedef long coord_t;
typedef double coordf_t;
namespace Slic3r {
enum Axis { X=0, Y, Z };
template <class T>
inline void append_to(std::vector<T> &dst, const std::vector<T> &src)
{
dst.insert(dst.end(), src.begin(), src.end());
}
}
using namespace Slic3r;
/* Implementation of CONFESS("foo"): */
#ifdef _MSC_VER
#define CONFESS(...) confess_at(__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)
@ -69,4 +58,56 @@ void confess_at(const char *file, int line, const char *func, const char *pat, .
#define STDMOVE(WHAT) (WHAT)
#endif
namespace Slic3r {
enum Axis { X=0, Y, Z };
template <class T>
inline void append_to(std::vector<T> &dst, const std::vector<T> &src)
{
dst.insert(dst.end(), src.begin(), src.end());
}
template <class T> void
_parallelize_do(std::queue<T>* queue, boost::mutex* queue_mutex, boost::function<void(T)> func)
{
//std::cout << "THREAD STARTED: " << boost::this_thread::get_id() << std::endl;
while (true) {
T i;
{
boost::lock_guard<boost::mutex> l(*queue_mutex);
if (queue->empty()) return;
i = queue->front();
queue->pop();
}
//std::cout << " Thread " << boost::this_thread::get_id() << " processing item " << i << std::endl;
func(i);
boost::this_thread::interruption_point();
}
}
template <class T> void
parallelize(std::queue<T> queue, boost::function<void(T)> func,
int threads_count = boost::thread::hardware_concurrency())
{
boost::mutex queue_mutex;
boost::thread_group workers;
for (int i = 0; i < threads_count; i++)
workers.add_thread(new boost::thread(&_parallelize_do<T>, &queue, &queue_mutex, func));
workers.join_all();
}
template <class T> void
parallelize(T start, T end, boost::function<void(T)> func,
int threads_count = boost::thread::hardware_concurrency())
{
std::queue<T> queue;
for (T i = start; i <= end; ++i) queue.push(i);
parallelize(queue, func, threads_count);
}
} // namespace Slic3r
using namespace Slic3r;
#endif