| 1 |
/* |
| 2 |
Copyright (c) 2005-2021 Intel Corporation |
| 3 |
|
| 4 |
Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 |
you may not use this file except in compliance with the License. |
| 6 |
You may obtain a copy of the License at |
| 7 |
|
| 8 |
http://www.apache.org/licenses/LICENSE-2.0 |
| 9 |
|
| 10 |
Unless required by applicable law or agreed to in writing, software |
| 11 |
distributed under the License is distributed on an "AS IS" BASIS, |
| 12 |
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 |
See the License for the specific language governing permissions and |
| 14 |
limitations under the License. |
| 15 |
*/ |
| 16 |
|
| 17 |
#include <cmath> |
| 18 |
#include <cstdio> |
| 19 |
|
| 20 |
#include "oneapi/tbb/parallel_for.h" |
| 21 |
#include "oneapi/tbb/blocked_range2d.h" |
| 22 |
#include "oneapi/tbb/tick_count.h" |
| 23 |
|
| 24 |
#include "fractal.hpp" |
| 25 |
|
| 26 |
video *v; |
| 27 |
extern bool silent; |
| 28 |
extern bool schedule_auto; |
| 29 |
extern int grain_size; |
| 30 |
|
| 31 |
color_t fractal::calc_one_pixel(int x0, int y0) const { |
| 32 |
unsigned int iter; |
| 33 |
double fx0, fy0, xtemp, x, y, mu; |
| 34 |
|
| 35 |
color_t color; |
| 36 |
|
| 37 |
fx0 = (double)x0 - (double)size_x / 2.0; |
| 38 |
fy0 = (double)y0 - (double)size_y / 2.0; |
| 39 |
fx0 = fx0 / magn + cx; |
| 40 |
fy0 = fy0 / magn + cy; |
| 41 |
|
| 42 |
iter = 0; |
| 43 |
x = 0; |
| 44 |
y = 0; |
| 45 |
mu = 0; |
| 46 |
|
| 47 |
while (((x * x + y * y) <= 4) && (iter < max_iterations)) { |
| 48 |
xtemp = x * x - y * y + fx0; |
| 49 |
y = 2 * x * y + fy0; |
| 50 |
x = xtemp; |
| 51 |
mu += exp(-sqrt(x * x + y * y)); |
| 52 |
iter++; |
| 53 |
} |
| 54 |
|
| 55 |
if (iter == max_iterations) { |
| 56 |
// point corresponds to the mandelbrot set |
| 57 |
color = v->get_color(255, 255, 255); |
| 58 |
return color; |
| 59 |
} |
| 60 |
|
| 61 |
int b = (int)(256 * mu); |
| 62 |
int g = (b / 8); |
| 63 |
int r = (g / 16); |
| 64 |
|
| 65 |
b = b > 255 ? 255 : b; |
| 66 |
g = g > 255 ? 255 : g; |
| 67 |
r = r > 255 ? 255 : r; |
| 68 |
|
| 69 |
color = v->get_color(r, g, b); |
| 70 |
return color; |
| 71 |
} |
| 72 |
|
| 73 |
void fractal::clear() { |
| 74 |
drawing_area area(off_x, off_y, size_x, size_y, dm); |
| 75 |
|
| 76 |
// fill the rendering area with black color |
| 77 |
for (int y = 0; y < size_y; ++y) { |
| 78 |
area.set_pos(0, y); |
| 79 |
for (int x = 0; x < size_x; ++x) { |
| 80 |
area.put_pixel(v->get_color(0, 0, 0)); |
| 81 |
} |
| 82 |
} |
| 83 |
} |
| 84 |
|
| 85 |
void fractal::draw_border(bool is_active) { |
| 86 |
color_t color = is_active ? v->get_color(0, 255, 0) // green color |
| 87 |
: v->get_color(96, 128, 96); // green-gray color |
| 88 |
|
| 89 |
// top border |
| 90 |
drawing_area area0(off_x - 1, off_y - 1, size_x + 2, 1, dm); |
| 91 |
for (int i = -1; i < size_x + 1; ++i) |
| 92 |
area0.put_pixel(color); |
| 93 |
// bottom border |
| 94 |
drawing_area area1(off_x - 1, off_y + size_y, size_x + 2, 1, dm); |
| 95 |
for (int i = -1; i < size_x + 1; ++i) |
| 96 |
area1.put_pixel(color); |
| 97 |
// left border |
| 98 |
drawing_area area2(off_x - 1, off_y, 1, size_y + 2, dm); |
| 99 |
for (int i = 0; i < size_y; ++i) |
| 100 |
area2.set_pixel(0, i, color); |
| 101 |
// right border |
| 102 |
drawing_area area3(size_x + off_x, off_y, 1, size_y + 2, dm); |
| 103 |
for (int i = 0; i < size_y; ++i) |
| 104 |
area3.set_pixel(0, i, color); |
| 105 |
} |
| 106 |
|
| 107 |
void fractal::render_rect(int x0, int y0, int x1, int y1) const { |
| 108 |
// render the specified rectangle area |
| 109 |
drawing_area area(off_x + x0, off_y + y0, x1 - x0, y1 - y0, dm); |
| 110 |
for (int y = y0; y < y1; ++y) { |
| 111 |
area.set_pos(0, y - y0); |
| 112 |
for (int x = x0; x < x1; ++x) { |
| 113 |
area.put_pixel(calc_one_pixel(x, y)); |
| 114 |
} |
| 115 |
} |
| 116 |
} |
| 117 |
|
| 118 |
class fractal_body { |
| 119 |
fractal &f; |
| 120 |
|
| 121 |
public: |
| 122 |
void operator()(oneapi::tbb::blocked_range2d<int> &r) const { |
| 123 |
if (v->next_frame()) |
| 124 |
f.render_rect(r.cols().begin(), r.rows().begin(), r.cols().end(), r.rows().end()); |
| 125 |
} |
| 126 |
|
| 127 |
fractal_body(fractal &_f) : f(_f) {} |
| 128 |
}; |
| 129 |
|
| 130 |
void fractal::render(oneapi::tbb::task_group_context &context) { |
| 131 |
// Make copy of fractal object and render fractal with parallel_for with |
| 132 |
// the provided context and partitioner chosen by schedule_auto. |
| 133 |
// Updates to fractal are not reflected in the render. |
| 134 |
fractal f = *this; |
| 135 |
fractal_body body(f); |
| 136 |
|
| 137 |
if (schedule_auto) |
| 138 |
oneapi::tbb::parallel_for( |
| 139 |
oneapi::tbb::blocked_range2d<int>(0, size_y, grain_size, 0, size_x, grain_size), |
| 140 |
body, |
| 141 |
oneapi::tbb::auto_partitioner(), |
| 142 |
context); |
| 143 |
else |
| 144 |
oneapi::tbb::parallel_for( |
| 145 |
oneapi::tbb::blocked_range2d<int>(0, size_y, grain_size, 0, size_x, grain_size), |
| 146 |
body, |
| 147 |
oneapi::tbb::simple_partitioner(), |
| 148 |
context); |
| 149 |
} |
| 150 |
|
| 151 |
void fractal::run(oneapi::tbb::task_group_context &context) { |
| 152 |
clear(); |
| 153 |
context.reset(); |
| 154 |
render(context); |
| 155 |
} |
| 156 |
|
| 157 |
bool fractal::check_point(int x, int y) const { |
| 158 |
return x >= off_x && x <= off_x + size_x && y >= off_y && y <= off_y + size_y; |
| 159 |
} |
| 160 |
|
| 161 |
void fractal_group::calc_fractal(int num) { |
| 162 |
// calculate the fractal |
| 163 |
fractal &f = num ? f1 : f0; |
| 164 |
|
| 165 |
oneapi::tbb::tick_count t0 = oneapi::tbb::tick_count::now(); |
| 166 |
while (v->next_frame() && num_frames[num] != 0) { |
| 167 |
f.run(context[num]); |
| 168 |
if (num_frames[num] > 0) |
| 169 |
num_frames[num] -= 1; |
| 170 |
} |
| 171 |
oneapi::tbb::tick_count t1 = oneapi::tbb::tick_count::now(); |
| 172 |
|
| 173 |
if (!silent) { |
| 174 |
printf(" %s fractal finished. Time: %g\n", num ? "Second" : "First", (t1 - t0).seconds()); |
| 175 |
} |
| 176 |
} |
| 177 |
|
| 178 |
void fractal_group::switch_active(int new_active) { |
| 179 |
if (new_active != -1) |
| 180 |
active = new_active; |
| 181 |
else |
| 182 |
active = 1 - active; // assumes 'active' is only 0 or 1 |
| 183 |
draw_borders(); |
| 184 |
} |
| 185 |
|
| 186 |
void fractal_group::set_num_frames_at_least(int n) { |
| 187 |
if (num_frames[0] < n) |
| 188 |
num_frames[0] = n; |
| 189 |
if (num_frames[1] < n) |
| 190 |
num_frames[1] = n; |
| 191 |
} |
| 192 |
|
| 193 |
void fractal_group::run(bool create_second_fractal) { |
| 194 |
// First argument of arenas construntor is used to restrict concurrency |
| 195 |
arenas[0].initialize(num_threads); |
| 196 |
arenas[1].initialize(num_threads / 2); |
| 197 |
|
| 198 |
draw_borders(); |
| 199 |
|
| 200 |
// the second fractal is calculating on separated thread |
| 201 |
if (create_second_fractal) { |
| 202 |
arenas[1].execute([&] { |
| 203 |
groups[1].run([&] { |
| 204 |
calc_fractal(1); |
| 205 |
}); |
| 206 |
}); |
| 207 |
} |
| 208 |
|
| 209 |
arenas[0].execute([&] { |
| 210 |
groups[0].run([&] { |
| 211 |
calc_fractal(0); |
| 212 |
}); |
| 213 |
}); |
| 214 |
|
| 215 |
if (create_second_fractal) { |
| 216 |
arenas[1].execute([&] { |
| 217 |
groups[1].wait(); |
| 218 |
}); |
| 219 |
} |
| 220 |
|
| 221 |
arenas[0].execute([&] { |
| 222 |
groups[0].wait(); |
| 223 |
}); |
| 224 |
} |
| 225 |
|
| 226 |
void fractal_group::draw_borders() { |
| 227 |
f0.draw_border(active == 0); |
| 228 |
f1.draw_border(active == 1); |
| 229 |
} |
| 230 |
|
| 231 |
fractal_group::fractal_group(const drawing_memory &_dm, |
| 232 |
int _num_threads, |
| 233 |
unsigned int _max_iterations, |
| 234 |
int _num_frames) |
| 235 |
: f0(_dm), |
| 236 |
f1(_dm), |
| 237 |
num_threads(_num_threads) { |
| 238 |
// set rendering areas |
| 239 |
f0.size_x = f1.size_x = _dm.sizex / 2 - 4; |
| 240 |
f0.size_y = f1.size_y = _dm.sizey - 4; |
| 241 |
f0.off_x = f0.off_y = f1.off_y = 2; |
| 242 |
f1.off_x = f0.size_x + 4 + 2; |
| 243 |
|
| 244 |
// set fractals parameters |
| 245 |
f0.cx = -0.6f; |
| 246 |
f0.cy = 0.0f; |
| 247 |
f0.magn = 200.0f; |
| 248 |
f1.cx = -0.6f; |
| 249 |
f1.cy = 0.0f; |
| 250 |
f1.magn = 200.0f; |
| 251 |
f0.max_iterations = f1.max_iterations = _max_iterations; |
| 252 |
|
| 253 |
// initially the first fractal is active |
| 254 |
active = 0; |
| 255 |
|
| 256 |
num_frames[0] = num_frames[1] = _num_frames; |
| 257 |
} |
| 258 |
|
| 259 |
void fractal_group::mouse_click(int x, int y) { |
| 260 |
// assumption that the point is not inside any fractal area |
| 261 |
int new_active = -1; |
| 262 |
|
| 263 |
if (f0.check_point(x, y)) { |
| 264 |
// the point is inside the first fractal area |
| 265 |
new_active = 0; |
| 266 |
} |
| 267 |
else if (f1.check_point(x, y)) { |
| 268 |
// the point is inside the second fractal area |
| 269 |
new_active = 1; |
| 270 |
} |
| 271 |
|
| 272 |
if (new_active != -1 && new_active != active) { |
| 273 |
switch_active(new_active); |
| 274 |
} |
| 275 |
} |