MandelbrotThread Class Reference

#include <mandelbrot.h>

Inheritance diagram for MandelbrotThread:

Public Member Functions
	MandelbrotThread (MandelbrotWidget *w, int i)
void	run ()
template<typename Real >
void	render (int img_width, int img_height)

Private Attributes
MandelbrotWidget *	widget
long long	total_iter
int	id
int	max_iter
bool	single_precision

Friends
class	MandelbrotWidget

Constructor & Destructor Documentation

MandelbrotThread()

MandelbrotThread::MandelbrotThread ( MandelbrotWidget *  w, int  i  )

inline

: widget(w), id(i) {}

Member Function Documentation

render()

template<typename Real >

void MandelbrotThread::render	(	int	img_width,
		int	img_height
	)

                                                           {
  enum { packetSize = Eigen::internal::packet_traits<Real>::size };  // number of reals in a Packet
  typedef Eigen::Array<Real, packetSize, 1> Packet;                  // wrap a Packet as a vector
 
  enum { iters_before_test = iters_before_test<Real>::ret };
  max_iter = (max_iter / iters_before_test) * iters_before_test;
  const int alignedWidth = (img_width / packetSize) * packetSize;
  unsigned char *const buffer = widget->buffer;
  const double xradius = widget->xradius;
  const double yradius = xradius * img_height / img_width;
  const int threadcount = widget->threadcount;
  typedef Eigen::Array<Real, 2, 1> Vector2;
  Vector2 start(widget->center.x() - widget->xradius, widget->center.y() - yradius);
  Vector2 step(2 * widget->xradius / img_width, 2 * yradius / img_height);
  total_iter = 0;
 
  for (int y = id; y < img_height; y += threadcount) {
    int pix = y * img_width;
 
    // for each pixel, we're going to do the iteration z := z^2 + c where z and c are complex numbers,
    // starting with z = c = complex coord of the pixel. pzi and pzr denote the real and imaginary parts of z.
    // pci and pcr denote the real and imaginary parts of c.
 
    Packet pzi_start, pci_start;
    for (int i = 0; i < packetSize; i++) pzi_start[i] = pci_start[i] = start.y() + y * step.y();
 
    for (int x = 0; x < alignedWidth; x += packetSize, pix += packetSize) {
      Packet pcr, pci = pci_start, pzr, pzi = pzi_start, pzr_buf;
      for (int i = 0; i < packetSize; i++) pzr[i] = pcr[i] = start.x() + (x + i) * step.x();
 
      // do the iterations. Every iters_before_test iterations we check for divergence,
      // in which case we can stop iterating.
      int j = 0;
      typedef Eigen::Matrix<int, packetSize, 1> Packeti;
      Packeti pix_iter = Packeti::Zero(),  // number of iteration per pixel in the packet
          pix_dont_diverge;                // whether or not each pixel has already diverged
      do {
        for (int i = 0; i < iters_before_test / 4; i++)  // peel the inner loop by 4
        {
#define ITERATE              \
  pzr_buf = pzr;             \
  pzr = pzr.square();        \
  pzr -= pzi.square();       \
  pzr += pcr;                \
  pzi = (2 * pzr_buf) * pzi; \
  pzi += pci;
          ITERATE ITERATE ITERATE ITERATE
        }
        pix_dont_diverge =
            ((pzr.square() + pzi.square()).eval()  // temporary fix as what follows is not yet vectorized by Eigen
             <= Packet::Constant(4))
                // the 4 here is not a magic value, it's a math fact that if
                // the square modulus is >4 then divergence is inevitable.
                .template cast<int>();
        pix_iter += iters_before_test * pix_dont_diverge;
        j++;
        total_iter += iters_before_test * packetSize;
      } while (j < max_iter / iters_before_test && pix_dont_diverge.any());  // any() is not yet vectorized by Eigen
 
      // compute pixel colors
      for (int i = 0; i < packetSize; i++) {
        buffer[4 * (pix + i)] = 255 * pix_iter[i] / max_iter;
        buffer[4 * (pix + i) + 1] = 0;
        buffer[4 * (pix + i) + 2] = 0;
      }
    }
 
    // if the width is not a multiple of packetSize, fill the remainder in black
    for (int x = alignedWidth; x < img_width; x++, pix++)
      buffer[4 * pix] = buffer[4 * pix + 1] = buffer[4 * pix + 2] = 0;
  }
  return;
}

References MandelbrotWidget::buffer, MandelbrotWidget::center, eval(), i, ITERATE, j, max_iter, oomph::CumulativeTimings::start(), MandelbrotWidget::threadcount, total_iter, widget, plotDoE::x, MandelbrotWidget::xradius, y, and oomph::PseudoSolidHelper::Zero.

run()

void MandelbrotThread::run

(

)

                           {
  setTerminationEnabled(true);
  double resolution = widget->xradius * 2 / widget->width();
  max_iter = 128;
  if (resolution < 1e-4f) max_iter += 128 * (-4 - std::log10(resolution));
  int img_width = widget->width() / widget->draft;
  int img_height = widget->height() / widget->draft;
  single_precision = resolution > 1e-7f;
 
  if (single_precision)
    render<float>(img_width, img_height);
  else
    render<double>(img_width, img_height);
}

References MandelbrotWidget::draft, Eigen::bfloat16_impl::log10(), max_iter, single_precision, widget, and MandelbrotWidget::xradius.

Friends And Related Function Documentation

MandelbrotWidget

friend class MandelbrotWidget

friend

Member Data Documentation

id

int MandelbrotThread::id

private

max_iter

int MandelbrotThread::max_iter

private

Referenced by render(), and run().

single_precision

bool MandelbrotThread::single_precision

private

Referenced by MandelbrotWidget::paintEvent(), and run().

total_iter

long long MandelbrotThread::total_iter

private

Referenced by MandelbrotWidget::paintEvent(), and render().

widget

MandelbrotWidget* MandelbrotThread::widget

private

Referenced by render(), and run().

---

The documentation for this class was generated from the following files:

• mandelbrot.h
• mandelbrot.cpp