7 files changed, 364 insertions, 231 deletions

diff --git a/source/blender/bmesh/bmesh_class.h b/source/blender/bmesh/bmesh_class.h
index 9d797c1e602..4a370a24c7d 100644
--- a/source/blender/bmesh/bmesh_class.h
+++ b/source/blender/bmesh/bmesh_class.h
@@ -187,8 +187,9 @@ typedef struct BMesh {
 	/*element pools*/
 	struct BLI_mempool *vpool, *epool, *lpool, *fpool;
 
-	/*operator api stuff*/
-	struct BLI_mempool *toolflagpool;
+	/*operator api stuff (must be all NULL or all alloc'd)*/
+	struct BLI_mempool *vtoolflagpool, *etoolflagpool, *ftoolflagpool;
+
 	int stackdepth;
 	struct BMOperator *currentop;
 	
diff --git a/source/blender/bmesh/intern/bmesh_core.c b/source/blender/bmesh/intern/bmesh_core.c
index 870d0f3d7dd..ea9ab364b84 100644
--- a/source/blender/bmesh/intern/bmesh_core.c
+++ b/source/blender/bmesh/intern/bmesh_core.c
@@ -79,8 +79,8 @@ BMVert *BM_vert_create(BMesh *bm, const float co[3], const BMVert *example, cons
 	}
 
 	/* allocate flags */
-	if (bm->toolflagpool) {
-		v->oflags = BLI_mempool_calloc(bm->toolflagpool);
+	if (bm->vtoolflagpool) {
+		v->oflags = BLI_mempool_calloc(bm->vtoolflagpool);
 	}
 
 	if (!(create_flag & BM_CREATE_SKIP_CD)) {
@@ -133,8 +133,8 @@ BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example,
 	e->head.htype = BM_EDGE;
 	
 	/* allocate flags */
-	if (bm->toolflagpool) {
-		e->oflags = BLI_mempool_calloc(bm->toolflagpool);
+	if (bm->etoolflagpool) {
+		e->oflags = BLI_mempool_calloc(bm->etoolflagpool);
 	}
 
 	e->v1 = v1;
@@ -291,8 +291,8 @@ BLI_INLINE BMFace *bm_face_create__internal(BMesh *bm, const eBMCreateFlag creat
 	f->head.htype = BM_FACE;
 
 	/* allocate flags */
-	if (bm->toolflagpool) {
-		f->oflags = BLI_mempool_calloc(bm->toolflagpool);
+	if (bm->ftoolflagpool) {
+		f->oflags = BLI_mempool_calloc(bm->ftoolflagpool);
 	}
 
 	if (!(create_flag & BM_CREATE_SKIP_CD)) {
@@ -512,8 +512,8 @@ static void bm_kill_only_vert(BMesh *bm, BMVert *v)
 	if (v->head.data)
 		CustomData_bmesh_free_block(&bm->vdata, &v->head.data);
 
-	if (bm->toolflagpool) {
-		BLI_mempool_free(bm->toolflagpool, v->oflags);
+	if (bm->vtoolflagpool) {
+		BLI_mempool_free(bm->vtoolflagpool, v->oflags);
 	}
 	BLI_mempool_free(bm->vpool, v);
 }
@@ -532,8 +532,8 @@ static void bm_kill_only_edge(BMesh *bm, BMEdge *e)
 	if (e->head.data)
 		CustomData_bmesh_free_block(&bm->edata, &e->head.data);
 
-	if (bm->toolflagpool) {
-		BLI_mempool_free(bm->toolflagpool, e->oflags);
+	if (bm->etoolflagpool) {
+		BLI_mempool_free(bm->etoolflagpool, e->oflags);
 	}
 	BLI_mempool_free(bm->epool, e);
 }
@@ -555,8 +555,8 @@ static void bm_kill_only_face(BMesh *bm, BMFace *f)
 	if (f->head.data)
 		CustomData_bmesh_free_block(&bm->pdata, &f->head.data);
 
-	if (bm->toolflagpool) {
-		BLI_mempool_free(bm->toolflagpool, f->oflags);
+	if (bm->ftoolflagpool) {
+		BLI_mempool_free(bm->ftoolflagpool, f->oflags);
 	}
 	BLI_mempool_free(bm->fpool, f);
 }
@@ -1785,8 +1785,8 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
 	bmesh_disk_edge_remove(f1loop->e, f1loop->e->v2);
 	
 	/* deallocate edge and its two loops as well as f2 */
-	if (bm->toolflagpool) {
-		BLI_mempool_free(bm->toolflagpool, f1loop->e->oflags);
+	if (bm->etoolflagpool) {
+		BLI_mempool_free(bm->etoolflagpool, f1loop->e->oflags);
 	}
 	BLI_mempool_free(bm->epool, f1loop->e);
 	bm->totedge--;
@@ -1794,8 +1794,8 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
 	bm->totloop--;
 	BLI_mempool_free(bm->lpool, f2loop);
 	bm->totloop--;
-	if (bm->toolflagpool) {
-		BLI_mempool_free(bm->toolflagpool, f2->oflags);
+	if (bm->ftoolflagpool) {
+		BLI_mempool_free(bm->ftoolflagpool, f2->oflags);
 	}
 	BLI_mempool_free(bm->fpool, f2);
 	bm->totface--;
diff --git a/source/blender/bmesh/intern/bmesh_marking.c b/source/blender/bmesh/intern/bmesh_marking.c
index 9af65d7dd7e..6093547150c 100644
--- a/source/blender/bmesh/intern/bmesh_marking.c
+++ b/source/blender/bmesh/intern/bmesh_marking.c
@@ -44,8 +44,6 @@
 
 static void recount_totsels(BMesh *bm)
 {
-	BMIter iter;
-	BMElem *ele;
 	const char iter_types[3] = {BM_VERTS_OF_MESH,
 	                            BM_EDGES_OF_MESH,
 	                            BM_FACES_OF_MESH};
@@ -58,11 +56,16 @@ static void recount_totsels(BMesh *bm)
 	tots[1] = &bm->totedgesel;
 	tots[2] = &bm->totfacesel;
 
+#pragma omp parallel for schedule(dynamic)
 	for (i = 0; i < 3; i++) {
-		ele = BM_iter_new(&iter, bm, iter_types[i], NULL);
-		for ( ; ele; ele = BM_iter_step(&iter)) {
-			if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) *tots[i] += 1;
+		BMIter iter;
+		BMElem *ele;
+		int count = 0;
+
+		BM_ITER_MESH (ele, &iter, bm, iter_types[i]) {
+			if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) count += 1;
 		}
+		*tots[i] = count;
 	}
 }
 
@@ -161,34 +164,45 @@ void BM_mesh_deselect_flush(BMesh *bm)
 
 	int ok;
 
-	BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
-		if (!(BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
-		      BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
-		      !BM_elem_flag_test(e, BM_ELEM_HIDDEN)))
+	/* we can use 2 sections here because the second loop isnt checking edge selection */
+#pragma omp parallel sections
+	{
+#pragma omp section
 		{
-			BM_elem_flag_disable(e, BM_ELEM_SELECT);
+			BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
+				if (!(BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
+				      BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
+				      !BM_elem_flag_test(e, BM_ELEM_HIDDEN)))
+				{
+					BM_elem_flag_disable(e, BM_ELEM_SELECT);
+				}
+			}
 		}
-	}
 
-	BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
-		ok = TRUE;
-		if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
-			l_iter = l_first = BM_FACE_FIRST_LOOP(f);
-			do {
-				if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) {
+#pragma omp section
+		{
+			BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
+				ok = TRUE;
+				if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
+					l_iter = l_first = BM_FACE_FIRST_LOOP(f);
+					do {
+						if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) {
+							ok = FALSE;
+							break;
+						}
+					} while ((l_iter = l_iter->next) != l_first);
+				}
+				else {
 					ok = FALSE;
-					break;
 				}
-			} while ((l_iter = l_iter->next) != l_first);
-		}
-		else {
-			ok = FALSE;
-		}
 
-		if (ok == FALSE) {
-			BM_elem_flag_disable(f, BM_ELEM_SELECT);
+				if (ok == FALSE) {
+					BM_elem_flag_disable(f, BM_ELEM_SELECT);
+				}
+			}
 		}
 	}
+	/* end sections */
 
 	/* Remove any deselected elements from the BMEditSelection */
 	BM_select_history_validate(bm);
@@ -212,32 +226,42 @@ void BM_mesh_select_flush(BMesh *bm)
 
 	int ok;
 
-	BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
-		if (BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
-		    BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
-		    !BM_elem_flag_test(e, BM_ELEM_HIDDEN))
+	/* we can use 2 sections here because the second loop isnt checking edge selection */
+#pragma omp parallel sections
+	{
+#pragma omp section
 		{
-			BM_elem_flag_enable(e, BM_ELEM_SELECT);
+			BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
+				if (BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
+				    BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
+				    !BM_elem_flag_test(e, BM_ELEM_HIDDEN))
+				{
+					BM_elem_flag_enable(e, BM_ELEM_SELECT);
+				}
+			}
 		}
-	}
 
-	BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
-		ok = TRUE;
-		if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
-			l_iter = l_first = BM_FACE_FIRST_LOOP(f);
-			do {
-				if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) {
+#pragma omp section
+		{
+			BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
+				ok = TRUE;
+				if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
+					l_iter = l_first = BM_FACE_FIRST_LOOP(f);
+					do {
+						if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) {
+							ok = FALSE;
+							break;
+						}
+					} while ((l_iter = l_iter->next) != l_first);
+				}
+				else {
 					ok = FALSE;
-					break;
 				}
-			} while ((l_iter = l_iter->next) != l_first);
-		}
-		else {
-			ok = FALSE;
-		}
 
-		if (ok) {
-			BM_elem_flag_enable(f, BM_ELEM_SELECT);
+				if (ok) {
+					BM_elem_flag_enable(f, BM_ELEM_SELECT);
+				}
+			}
 		}
 	}
 
@@ -810,8 +834,6 @@ void BM_mesh_elem_hflag_disable_test(BMesh *bm, const char htype, const char hfl
 
 	const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE};
 
-	BMIter iter;
-	BMElem *ele;
 	int i;
 
 	if (hflag & BM_ELEM_SELECT) {
@@ -825,16 +847,25 @@ void BM_mesh_elem_hflag_disable_test(BMesh *bm, const char htype, const char hfl
 	{
 		/* fast path for deselect all, avoid topology loops
 		 * since we know all will be de-selected anyway. */
+
+#pragma omp parallel for schedule(dynamic)
 		for (i = 0; i < 3; i++) {
+			BMIter iter;
+			BMElem *ele;
+
 			ele = BM_iter_new(&iter, bm, iter_types[i], NULL);
 			for ( ; ele; ele = BM_iter_step(&iter)) {
 				BM_elem_flag_disable(ele, BM_ELEM_SELECT);
 			}
 		}
+
 		bm->totvertsel = bm->totedgesel = bm->totfacesel = 0;
 	}
 	else {
 		for (i = 0; i < 3; i++) {
+			BMIter iter;
+			BMElem *ele;
+
 			if (htype & flag_types[i]) {
 				ele = BM_iter_new(&iter, bm, iter_types[i], NULL);
 				for ( ; ele; ele = BM_iter_step(&iter)) {
diff --git a/source/blender/bmesh/intern/bmesh_mesh.c b/source/blender/bmesh/intern/bmesh_mesh.c
index 590edc45d07..8d5bf46a6e5 100644
--- a/source/blender/bmesh/intern/bmesh_mesh.c
+++ b/source/blender/bmesh/intern/bmesh_mesh.c
@@ -63,40 +63,62 @@ static void bm_mempool_init(BMesh *bm, const BMAllocTemplate *allocsize)
 
 void BM_mesh_elem_toolflags_ensure(BMesh *bm)
 {
-	if (bm->toolflagpool == NULL) {
-		const int totflagpool_size = max_ii(512, bm->totvert + bm->totedge + bm->totface);
-		BLI_mempool *toolflagpool;
-
-		BMIter iter;
-		BMElemF *ele;
-		const char iter_types[3] = {BM_VERTS_OF_MESH,
-		                            BM_EDGES_OF_MESH,
-		                            BM_FACES_OF_MESH};
-
-		int i;
-
-		BLI_assert(bm->totflags == 0);
-
-		/* allocate one flag pool that we don't get rid of. */
-		toolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), totflagpool_size, 512, 0);
-
+	if (bm->vtoolflagpool && bm->etoolflagpool && bm->ftoolflagpool) {
+		return;
+	}
 
-		for (i = 0; i < 3; i++) {
-			BM_ITER_MESH (ele, &iter, bm, iter_types[i]) {
+	bm->vtoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), max_ii(512, bm->totvert), 512, 0);
+	bm->etoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), max_ii(512, bm->totedge), 512, 0);
+	bm->ftoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), max_ii(512, bm->totface), 512, 0);
+
+#pragma omp parallel sections
+	{
+#pragma omp section
+		{
+			BLI_mempool *toolflagpool = bm->vtoolflagpool;
+			BMIter iter;
+			BMElemF *ele;
+			BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
+				ele->oflags = BLI_mempool_calloc(toolflagpool);
+			}
+		}
+#pragma omp section
+		{
+			BLI_mempool *toolflagpool = bm->etoolflagpool;
+			BMIter iter;
+			BMElemF *ele;
+			BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
+				ele->oflags = BLI_mempool_calloc(toolflagpool);
+			}
+		}
+#pragma omp section
+		{
+			BLI_mempool *toolflagpool = bm->ftoolflagpool;
+			BMIter iter;
+			BMElemF *ele;
+			BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
 				ele->oflags = BLI_mempool_calloc(toolflagpool);
 			}
 		}
-
-		bm->toolflagpool = toolflagpool;
-		bm->totflags = 1;
 	}
+
+
+	bm->totflags = 1;
 }
 
 void BM_mesh_elem_toolflags_clear(BMesh *bm)
 {
-	if (bm->toolflagpool) {
-		BLI_mempool_destroy(bm->toolflagpool);
-		bm->toolflagpool = NULL;
+	if (bm->vtoolflagpool) {
+		BLI_mempool_destroy(bm->vtoolflagpool);
+		bm->vtoolflagpool = NULL;
+	}
+	if (bm->etoolflagpool) {
+		BLI_mempool_destroy(bm->etoolflagpool);
+		bm->etoolflagpool = NULL;
+	}
+	if (bm->ftoolflagpool) {
+		BLI_mempool_destroy(bm->ftoolflagpool);
+		bm->ftoolflagpool = NULL;
 	}
 }
 
@@ -446,50 +468,58 @@ void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag)
 	BM_ELEM_INDEX_VALIDATE(bm, "Should Never Fail!", __func__);
 #endif
 
-	if (hflag & BM_VERT) {
-		if (bm->elem_index_dirty & BM_VERT) {
-			int index = 0;
-			BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
-				BM_elem_index_set(ele, index); /* set_ok */
-				index++;
+#pragma omp parallel sections
+	{
+#pragma omp section
+		{
+			if (hflag & BM_VERT) {
+				if (bm->elem_index_dirty & BM_VERT) {
+					int index;
+					BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, index) {
+						BM_elem_index_set(ele, index); /* set_ok */
+					}
+					BLI_assert(index == bm->totvert);
+				}
+				else {
+					// printf("%s: skipping vert index calc!\n", __func__);
+				}
 			}
-			bm->elem_index_dirty &= ~BM_VERT;
-			BLI_assert(index == bm->totvert);
 		}
-		else {
-			// printf("%s: skipping vert index calc!\n", __func__);
-		}
-	}
 
-	if (hflag & BM_EDGE) {
-		if (bm->elem_index_dirty & BM_EDGE) {
-			int index = 0;
-			BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
-				BM_elem_index_set(ele, index); /* set_ok */
-				index++;
+#pragma omp section
+		{
+			if (hflag & BM_EDGE) {
+				if (bm->elem_index_dirty & BM_EDGE) {
+					int index;
+					BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, index) {
+						BM_elem_index_set(ele, index); /* set_ok */
+					}
+					BLI_assert(index == bm->totedge);
+				}
+				else {
+					// printf("%s: skipping edge index calc!\n", __func__);
+				}
 			}
-			bm->elem_index_dirty &= ~BM_EDGE;
-			BLI_assert(index == bm->totedge);
-		}
-		else {
-			// printf("%s: skipping edge index calc!\n", __func__);
 		}
-	}
 
-	if (hflag & BM_FACE) {
-		if (bm->elem_index_dirty & BM_FACE) {
-			int index = 0;
-			BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
-				BM_elem_index_set(ele, index); /* set_ok */
-				index++;
+#pragma omp section
+		{
+			if (hflag & BM_FACE) {
+				if (bm->elem_index_dirty & BM_FACE) {
+					int index;
+					BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, index) {
+						BM_elem_index_set(ele, index); /* set_ok */
+					}
+					BLI_assert(index == bm->totface);
+				}
+				else {
+					// printf("%s: skipping face index calc!\n", __func__);
+				}
 			}
-			bm->elem_index_dirty &= ~BM_FACE;
-			BLI_assert(index == bm->totface);
-		}
-		else {
-			// printf("%s: skipping face index calc!\n", __func__);
 		}
 	}
+
+	bm->elem_index_dirty &= ~hflag;
 }
 
 
diff --git a/source/blender/bmesh/intern/bmesh_operators.c b/source/blender/bmesh/intern/bmesh_operators.c
index 19f2b2f8978..f7dcb8ba483 100644
--- a/source/blender/bmesh/intern/bmesh_operators.c
+++ b/source/blender/bmesh/intern/bmesh_operators.c
@@ -599,6 +599,7 @@ void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *UNUSED(op), const char hty
 	BMElemF *ele;
 	int i;
 
+#pragma omp parallel for schedule(dynamic)
 	for (i = 0; i < 3; i++) {
 		if (htype & flag_types[i]) {
 			BM_ITER_MESH (ele, &iter, bm, iter_types[i]) {
@@ -1159,100 +1160,161 @@ void BMO_slot_buffer_flag_disable(BMesh *bm,
  */
 static void bmo_flag_layer_alloc(BMesh *bm)
 {
-	BMElemF *ele;
 	/* set the index values since we are looping over all data anyway,
 	 * may save time later on */
-	int i;
 
-	BMIter iter;
-	BLI_mempool *oldpool = bm->toolflagpool;  /* old flag pool */
-	BLI_mempool *newpool;
-	void *oldflags;
+	BLI_mempool *voldpool = bm->vtoolflagpool;  /* old flag pool */
+	BLI_mempool *eoldpool = bm->etoolflagpool;  /* old flag pool */
+	BLI_mempool *foldpool = bm->ftoolflagpool;  /* old flag pool */
 
 	/* store memcpy size for reuse */
 	const size_t old_totflags_size = (bm->totflags * sizeof(BMFlagLayer));
 
-	BLI_assert(oldpool != NULL);
-
 	bm->totflags++;
 
-	/* allocate new flag pool */
-	bm->toolflagpool = newpool = BLI_mempool_create(sizeof(BMFlagLayer) * bm->totflags, 512, 512, 0);
-	
-	/* now go through and memcpy all the flags. Loops don't get a flag layer at this time.. */
-	BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
-		oldflags = ele->oflags;
-		ele->oflags = BLI_mempool_calloc(newpool);
-		memcpy(ele->oflags, oldflags, old_totflags_size);
-		BM_elem_index_set(ele, i); /* set_inline */
-		BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
-	}
-	BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
-		oldflags = ele->oflags;
-		ele->oflags = BLI_mempool_calloc(newpool);
-		memcpy(ele->oflags, oldflags, old_totflags_size);
-		BM_elem_index_set(ele, i); /* set_inline */
-		BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
-	}
-	BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
-		oldflags = ele->oflags;
-		ele->oflags = BLI_mempool_calloc(newpool);
-		memcpy(ele->oflags, oldflags, old_totflags_size);
-		BM_elem_index_set(ele, i); /* set_inline */
-		BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
+	bm->vtoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer) * bm->totflags, max_ii(512, bm->totvert), 512, 0);
+	bm->etoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer) * bm->totflags, max_ii(512, bm->totedge), 512, 0);
+	bm->ftoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer) * bm->totflags, max_ii(512, bm->totface), 512, 0);
+
+#pragma omp parallel sections
+	{
+#pragma omp section
+		{
+			BMIter iter;
+			BMElemF *ele;
+			int i;
+
+			BLI_mempool *newpool = bm->vtoolflagpool;
+
+			/* now go through and memcpy all the flags. Loops don't get a flag layer at this time.. */
+			BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
+				void *oldflags = ele->oflags;
+				ele->oflags = BLI_mempool_calloc(newpool);
+				memcpy(ele->oflags, oldflags, old_totflags_size);
+				BM_elem_index_set(ele, i); /* set_inline */
+				BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
+			}
+		}
+#pragma omp section
+		{
+			BMIter iter;
+			BMElemF *ele;
+			int i;
+
+			BLI_mempool *newpool = bm->etoolflagpool;
+
+			BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
+				void *oldflags = ele->oflags;
+				ele->oflags = BLI_mempool_calloc(newpool);
+				memcpy(ele->oflags, oldflags, old_totflags_size);
+				BM_elem_index_set(ele, i); /* set_inline */
+				BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
+			}
+		}
+#pragma omp section
+		{
+			BMIter iter;
+			BMElemF *ele;
+			int i;
+
+			BLI_mempool *newpool = bm->ftoolflagpool;
+
+			BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
+				void *oldflags = ele->oflags;
+				ele->oflags = BLI_mempool_calloc(newpool);
+				memcpy(ele->oflags, oldflags, old_totflags_size);
+				BM_elem_index_set(ele, i); /* set_inline */
+				BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
+			}
+		}
 	}
 
+	BLI_mempool_destroy(voldpool);
+	BLI_mempool_destroy(eoldpool);
+	BLI_mempool_destroy(foldpool);
+
 	bm->elem_index_dirty &= ~(BM_VERT | BM_EDGE | BM_FACE);
 
-	BLI_mempool_destroy(oldpool);
+
 }
 
 static void bmo_flag_layer_free(BMesh *bm)
 {
-	BMElemF *ele;
 	/* set the index values since we are looping over all data anyway,
 	 * may save time later on */
-	int i;
 
-	BMIter iter;
-	BLI_mempool *oldpool = bm->toolflagpool;
-	BLI_mempool *newpool;
-	void *oldflags;
-	
+	BLI_mempool *voldpool = bm->vtoolflagpool;
+	BLI_mempool *eoldpool = bm->etoolflagpool;
+	BLI_mempool *foldpool = bm->ftoolflagpool;
+
 	/* store memcpy size for reuse */
 	const size_t new_totflags_size = ((bm->totflags - 1) * sizeof(BMFlagLayer));
 
 	/* de-increment the totflags first.. */
 	bm->totflags--;
-	/* allocate new flag pool */
-	bm->toolflagpool = newpool = BLI_mempool_create(new_totflags_size, 512, 512, 0);
-	
-	/* now go through and memcpy all the flags */
-	BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
-		oldflags = ele->oflags;
-		ele->oflags = BLI_mempool_calloc(newpool);
-		memcpy(ele->oflags, oldflags, new_totflags_size);
-		BM_elem_index_set(ele, i); /* set_inline */
-		BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
-	}
-	BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
-		oldflags = ele->oflags;
-		ele->oflags = BLI_mempool_calloc(newpool);
-		memcpy(ele->oflags, oldflags, new_totflags_size);
-		BM_elem_index_set(ele, i); /* set_inline */
-		BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
-	}
-	BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
-		oldflags = ele->oflags;
-		ele->oflags = BLI_mempool_calloc(newpool);
-		memcpy(ele->oflags, oldflags, new_totflags_size);
-		BM_elem_index_set(ele, i); /* set_inline */
-		BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
+
+	bm->vtoolflagpool = BLI_mempool_create(new_totflags_size, bm->totvert, 512, 0);
+	bm->etoolflagpool = BLI_mempool_create(new_totflags_size, bm->totedge, 512, 0);
+	bm->ftoolflagpool = BLI_mempool_create(new_totflags_size, bm->totface, 512, 0);
+
+#pragma omp parallel sections
+	{
+#pragma omp section
+		{
+			BMIter iter;
+			BMElemF *ele;
+			int i;
+
+			BLI_mempool *newpool = bm->vtoolflagpool;
+
+			/* now go through and memcpy all the flag */
+			BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
+				void *oldflags = ele->oflags;
+				ele->oflags = BLI_mempool_calloc(newpool);
+				memcpy(ele->oflags, oldflags, new_totflags_size);
+				BM_elem_index_set(ele, i); /* set_inline */
+				BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
+			}
+		}
+#pragma omp section
+		{
+			BMIter iter;
+			BMElemF *ele;
+			int i;
+
+			BLI_mempool *newpool = bm->etoolflagpool;
+
+			BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
+				void *oldflags = ele->oflags;
+				ele->oflags = BLI_mempool_calloc(newpool);
+				memcpy(ele->oflags, oldflags, new_totflags_size);
+				BM_elem_index_set(ele, i); /* set_inline */
+				BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
+			}
+		}
+#pragma omp section
+		{
+			BMIter iter;
+			BMElemF *ele;
+			int i;
+
+			BLI_mempool *newpool = bm->ftoolflagpool;
+
+			BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
+				void *oldflags = ele->oflags;
+				ele->oflags = BLI_mempool_calloc(newpool);
+				memcpy(ele->oflags, oldflags, new_totflags_size);
+				BM_elem_index_set(ele, i); /* set_inline */
+				BM_ELEM_API_FLAG_CLEAR((BMElemF *)ele);
+			}
+		}
 	}
 
-	bm->elem_index_dirty &= ~(BM_VERT | BM_EDGE | BM_FACE);
+	BLI_mempool_destroy(voldpool);
+	BLI_mempool_destroy(eoldpool);
+	BLI_mempool_destroy(foldpool);
 
-	BLI_mempool_destroy(oldpool);
+	bm->elem_index_dirty &= ~(BM_VERT | BM_EDGE | BM_FACE);
 }
 
 static void bmo_flag_layer_clear(BMesh *bm)
@@ -1261,22 +1323,35 @@ static void bmo_flag_layer_clear(BMesh *bm)
 	/* set the index values since we are looping over all data anyway,
 	 * may save time later on */
 	int i;
+	const BMFlagLayer zero_flag = {0};
 
 	BMIter iter;
 	const int totflags_offset = bm->totflags - 1;
 
-	/* now go through and memcpy all the flags */
-	BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
-		memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
-		BM_elem_index_set(ele, i); /* set_inline */
-	}
-	BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
-		memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
-		BM_elem_index_set(ele, i); /* set_inline */
-	}
-	BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
-		memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
-		BM_elem_index_set(ele, i); /* set_inline */
+#pragma omp parallel sections
+	{
+		/* now go through and memcpy all the flag */
+#pragma omp section
+		{
+			BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
+				ele->oflags[totflags_offset] = zero_flag;
+				BM_elem_index_set(ele, i); /* set_inline */
+			}
+		}
+#pragma omp section
+		{
+			BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
+				ele->oflags[totflags_offset] = zero_flag;
+				BM_elem_index_set(ele, i); /* set_inline */
+			}
+		}
+#pragma omp section
+		{
+			BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
+				ele->oflags[totflags_offset] = zero_flag;
+				BM_elem_index_set(ele, i); /* set_inline */
+			}
+		}
 	}
 
 	bm->elem_index_dirty &= ~(BM_VERT | BM_EDGE | BM_FACE);
diff --git a/source/blender/editors/mesh/editmesh_utils.c b/source/blender/editors/mesh/editmesh_utils.c
index 2cf63586142..6f5a61075ae 100644
--- a/source/blender/editors/mesh/editmesh_utils.c
+++ b/source/blender/editors/mesh/editmesh_utils.c
@@ -396,41 +396,34 @@ void EDBM_index_arrays_init(BMEditMesh *tm, int forvert, int foredge, int forfac
 	EDBM_index_arrays_free(tm);
 
 	if (forvert) {
-		BMIter iter;
-		BMVert *ele;
-		int i = 0;
-		
 		tm->vert_index = MEM_mallocN(sizeof(void **) * tm->bm->totvert, "tm->vert_index");
-
-		ele = BM_iter_new(&iter, tm->bm, BM_VERTS_OF_MESH, NULL);
-		for ( ; ele; ele = BM_iter_step(&iter)) {
-			tm->vert_index[i++] = ele;
-		}
 	}
-
 	if (foredge) {
-		BMIter iter;
-		BMEdge *ele;
-		int i = 0;
-		
 		tm->edge_index = MEM_mallocN(sizeof(void **) * tm->bm->totedge, "tm->edge_index");
-
-		ele = BM_iter_new(&iter, tm->bm, BM_EDGES_OF_MESH, NULL);
-		for ( ; ele; ele = BM_iter_step(&iter)) {
-			tm->edge_index[i++] = ele;
-		}
 	}
-
 	if (forface) {
-		BMIter iter;
-		BMFace *ele;
-		int i = 0;
-		
 		tm->face_index = MEM_mallocN(sizeof(void **) * tm->bm->totface, "tm->face_index");
+	}
 
-		ele = BM_iter_new(&iter, tm->bm, BM_FACES_OF_MESH, NULL);
-		for ( ; ele; ele = BM_iter_step(&iter)) {
-			tm->face_index[i++] = ele;
+#pragma omp parallel sections
+	{
+#pragma omp section
+		{
+			if (forvert) {
+				BM_iter_as_array(tm->bm, BM_VERTS_OF_MESH, NULL, (void **)tm->vert_index, tm->bm->totvert);
+			}
+		}
+#pragma omp section
+		{
+			if (foredge) {
+				BM_iter_as_array(tm->bm, BM_EDGES_OF_MESH, NULL, (void **)tm->edge_index, tm->bm->totedge);
+			}
+		}
+#pragma omp section
+		{
+			if (forface) {
+				BM_iter_as_array(tm->bm, BM_FACES_OF_MESH, NULL, (void **)tm->face_index, tm->bm->totface);
+			}
 		}
 	}
 }
@@ -1283,6 +1276,7 @@ void EDBM_mesh_reveal(BMEditMesh *em)
 
 	/* Use tag flag to remember what was hidden before all is revealed.
 	 * BM_ELEM_HIDDEN --> BM_ELEM_TAG */
+#pragma omp parallel for schedule(dynamic)
 	for (i = 0; i < 3; i++) {
 		BM_ITER_MESH (ele, &iter, em->bm, iter_types[i]) {
 			BM_elem_flag_set(ele, BM_ELEM_TAG, BM_elem_flag_test(ele, BM_ELEM_HIDDEN));
diff --git a/source/blender/modifiers/intern/MOD_decimate.c b/source/blender/modifiers/intern/MOD_decimate.c
index 28cdfa810fa..a23b677f8e6 100644
--- a/source/blender/modifiers/intern/MOD_decimate.c
+++ b/source/blender/modifiers/intern/MOD_decimate.c
@@ -188,7 +188,9 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	/* update for display only */
 	dmd->face_count = bm->totface;
 	result = CDDM_from_bmesh(bm, FALSE);
-	BLI_assert(bm->toolflagpool == NULL);  /* make sure we never alloc'd this */
+	BLI_assert(bm->vtoolflagpool == NULL);  /* make sure we never alloc'd this */
+	BLI_assert(bm->etoolflagpool == NULL);
+	BLI_assert(bm->ftoolflagpool == NULL);
 	BM_mesh_free(bm);
 
 #ifdef USE_TIMEIT