Производительность шаблона карты в многопоточной программе ниже, чем ожидалось (4-кратное ускорение против 8-кратного)

Я начинаю многопоточное программирование, поэтому извините, если следующее кажется очевидным. Я добавляю многопоточность в программу обработки изображений, и ускорение не совсем то, что я ожидал.

В настоящее время я получаю ускорение в 4 раза на процессоре с 4 физическими процессорами с гиперпоточностью (8), поэтому я хотел бы знать, ожидается ли такое ускорение. Единственное, о чем я могу думать, это то, что может иметь смысл, если обе гиперпотоки одного физического процессора должны совместно использовать какую-то шину памяти.

Будучи новичком в многопоточности, мне не совсем понятно, будет ли это рассматриваться как программа, связанная с вводом / выводом, учитывая, что вся память распределена в ОЗУ (я понимаю, что диспетчер виртуальной памяти моей ОС будет одним из тех, кто решит вставить / вывести страницу). это предполагаемый объем памяти из кучи) Моя машина имеет 16 ГБ ОЗУ на случай, если это поможет решить, может ли проблема с подкачкой страниц или перестановкой.

Я написал тестовую программу, демонстрирующую последовательный случай и два параллельных случая, используя QThreadPool и tbb :: parallel_for

Текущая программа, как вы можете видеть, не имеет никаких реальных операций, кроме установки предполагаемого изображения с черного на белый, и это сделано специально для того, чтобы узнать, какова базовая линия, прежде чем какие-либо реальные операции будут применены к изображению.

Я прилагаю программу в надежде, что кто-то может объяснить мне, если мой поиск ускорения примерно в 8 раз проиграл в этом алгоритме обработки. Обратите внимание, что меня не интересуют другие виды оптимизаций, такие как SIMD, так как моя реальная задача — не просто сделать это быстрее, а сделать это быстрее, используя чисто многопоточность, не вдаваясь в SSE или оптимизацию уровня кэша процессора.

#include <iostream>
#include <sys/time.h>

#include <vector>
#include <QThreadPool>
#include "/usr/local/include/tbb/tbb.h"
#define LOG(x) (std::cout << x << std::endl)

struct col4
{
unsigned char r, g, b, a;
};

class QTileTask : public QRunnable
{
public:
void run()
{
for(uint32_t y = m_yStart; y < m_yEnd; y++)
{
int rowStart = y * m_width;
for(uint32_t x = m_xStart; x < m_xEnd; x++)
{
int index = rowStart + x;
m_pData[index].r = 255;
m_pData[index].g = 255;
m_pData[index].b = 255;
m_pData[index].a = 255;
}
}
}

col4*          m_pData;
uint32_t       m_xStart;
uint32_t       m_yStart;
uint32_t       m_xEnd;
uint32_t       m_yEnd;
uint32_t       m_width;
};

struct TBBTileTask
{
void operator()()
{
for(uint32_t y = m_yStart; y < m_yEnd; y++)
{
int rowStart = y * m_width;
for(uint32_t x = m_xStart; x < m_xEnd; x++)
{
int index = rowStart + x;
m_pData[index].r = 255;
m_pData[index].g = 255;
m_pData[index].b = 255;
m_pData[index].a = 255;
}
}
}

col4*          m_pData;
uint32_t       m_xStart;
uint32_t       m_yStart;
uint32_t       m_xEnd;
uint32_t       m_yEnd;
uint32_t       m_width;
};

struct TBBCaller
{
TBBCaller(std::vector<TBBTileTask>& t)
: m_tasks(t)
{}

TBBCaller(TBBCaller& e, tbb::split)
: m_tasks(e.m_tasks)
{}

void operator()(const tbb::blocked_range<size_t>& r) const
{
for (size_t i=r.begin();i!=r.end();++i)
m_tasks[i]();
}

std::vector<TBBTileTask>& m_tasks;
};

inline double getcurrenttime( void )
{
timeval t;
gettimeofday(&t, NULL);
return static_cast<double>(t.tv_sec)+(static_cast<double>(t.tv_usec) / 1000000.0);
}

char* getCmdOption(char ** begin, char ** end, const std::string & option)
{
char ** itr = std::find(begin, end, option);
if (itr != end && ++itr != end)
{
return *itr;
}
return 0;
}

bool cmdOptionExists(char** begin, char** end, const std::string& option)
{
return std::find(begin, end, option) != end;
}

void baselineSerial(col4* pData, int resolution)
{
double t = getcurrenttime();
for(int y = 0; y < resolution; y++)
{
int rowStart = y * resolution;
for(int x = 0; x < resolution; x++)
{
int index = rowStart + x;
pData[index].r = 255;
pData[index].g = 255;
pData[index].b = 255;
pData[index].a = 255;
}
}
LOG((getcurrenttime() - t) * 1000 << " ms. (Serial)");
}

void baselineParallelQt(col4* pData, int resolution, uint32_t tileSize)
{
double t = getcurrenttime();

QThreadPool pool;
for(int y = 0; y < resolution; y+=tileSize)
{
for(int x = 0; x < resolution; x+=tileSize)
{
uint32_t xEnd = std::min<uint32_t>(x+tileSize, resolution);
uint32_t yEnd = std::min<uint32_t>(y+tileSize, resolution);

QTileTask* t = new QTileTask;
t->m_pData = pData;
t->m_xStart = x;
t->m_yStart = y;
t->m_xEnd = xEnd;
t->m_yEnd = yEnd;
t->m_width = resolution;
pool.start(t);
}
}
pool.waitForDone();
LOG((getcurrenttime() - t) * 1000 << " ms. (QThreadPool)");
}

void baselineParallelTBB(col4* pData, int resolution, uint32_t tileSize)
{
double t = getcurrenttime();

std::vector<TBBTileTask> tasks;
for(int y = 0; y < resolution; y+=tileSize)
{
for(int x = 0; x < resolution; x+=tileSize)
{
uint32_t xEnd = std::min<uint32_t>(x+tileSize, resolution);
uint32_t yEnd = std::min<uint32_t>(y+tileSize, resolution);

TBBTileTask t;
t.m_pData = pData;
t.m_xStart = x;
t.m_yStart = y;
t.m_xEnd = xEnd;
t.m_yEnd = yEnd;
t.m_width = resolution;
tasks.push_back(t);
}
}

TBBCaller caller(tasks);
tbb::task_scheduler_init init;
tbb::parallel_for(tbb::blocked_range<size_t>(0, tasks.size()), caller);

LOG((getcurrenttime() - t) * 1000 << " ms. (TBB)");
}

int main(int argc, char** argv)
{
int resolution = 1;
uint32_t tileSize = 64;

char * pResText = getCmdOption(argv, argv + argc, "-r");
if (pResText)
{
resolution = atoi(pResText);
}

char * pTileSizeChr = getCmdOption(argv, argv + argc, "-b");
if (pTileSizeChr)
{
tileSize = atoi(pTileSizeChr);
}

if(resolution > 16)
resolution = 16;

resolution = resolution << 10;

uint32_t tileCount = resolution/tileSize + 1;
tileCount *= tileCount;

LOG("Resolution: " << resolution << " Tile Size: "<< tileSize);
LOG("Tile Count: " << tileCount);

uint64_t pixelCount = resolution*resolution;
col4* pData = new col4[pixelCount];

memset(pData, 0, sizeof(col4)*pixelCount);
baselineSerial(pData, resolution);

memset(pData, 0, sizeof(col4)*pixelCount);
baselineParallelQt(pData, resolution, tileSize);

memset(pData, 0, sizeof(col4)*pixelCount);
baselineParallelTBB(pData, resolution, tileSize);

delete[] pData;

return 0;
}