C ++ dengan pthreads
Ini mencapai n = 14 hanya dalam waktu kurang dari 1 menit pada mesin saya. Tetapi karena itu hanya laptop 2-inti, saya berharap bahwa mesin uji 8-inti dapat menyelesaikan n = 15 dalam waktu kurang dari 2 menit. Butuh sekitar 4:20 menit di mesin saya.
Saya benar-benar berharap untuk menghasilkan sesuatu yang lebih efisien. Sudah ada menjadi cara untuk menghitung penentu dari matriks biner lebih efisien. Saya ingin membuat semacam pendekatan pemrograman dinamis yang menghitung istilah +1 dan -1 dalam perhitungan determinan. Tapi sejauh ini belum cukup.
Karena hadiah akan segera kedaluwarsa, saya menerapkan pendekatan brute force standar:
- Simpulkan semua matriks Toeplitz yang mungkin.
- Lewati salah satu dari dua di setiap pasangan matriks yang dialihkan. Karena matriks dijelaskan oleh nilai bitmask, ini mudah dilakukan dengan melewatkan semua nilai di mana kebalikan dari bitmask lebih kecil dari bitmask itu sendiri.
- Yang ditentukan dihitung dengan dekomposisi LR buku teks. Kecuali untuk beberapa penyetelan kinerja kecil, peningkatan utama yang saya lakukan pada algoritma dari buku metode numerik kuliah saya adalah bahwa saya menggunakan strategi pivot yang lebih sederhana.
- Paralelisasi dilakukan dengan pthreads. Hanya menggunakan spasi reguler untuk nilai-nilai yang diproses oleh masing-masing thread menyebabkan penyeimbangan beban yang sangat buruk, jadi saya memperkenalkan beberapa swizzling.
Saya menguji ini di Mac OS, tapi saya menggunakan kode yang sama di Ubuntu sebelumnya, jadi saya harap ini akan dikompilasi dan dijalankan tanpa hambatan:
- Simpan kode dalam file dengan
.cppekstensi, mis optim.cpp.
- Kompilasi dengan
gcc -Ofast optim.cpp -lpthread -lstdc++.
- Jalankan dengan
time ./a.out 14 8. Argumen pertama adalah maksimum n. 14 harus selesai dalam waktu kurang dari 2 menit, tetapi akan lebih baik jika Anda bisa mencoba 15 juga. Argumen kedua adalah jumlah utas. Menggunakan nilai yang sama dengan jumlah inti mesin biasanya merupakan awal yang baik, tetapi mencoba beberapa variasi berpotensi meningkatkan waktu.
Beri tahu saya jika Anda memiliki masalah dalam membangun atau menjalankan kode.
#include <stdint.h>
#include <pthread.h>
#include <cstdlib>
#include <iostream>
static int NMax = 14;
static int ThreadCount = 4;
static pthread_mutex_t ThreadMutex;
static pthread_cond_t ThreadCond;
static int BarrierCount = 0;
static float* MaxDetA;
static uint32_t* MaxDescrA;
static inline float absVal(float val)
{
return val < 0.0f ? -val : val;
}
static uint32_t reverse(int n, uint32_t descr)
{
uint32_t descrRev = 0;
for (int iBit = 0; iBit < 2 * n - 1; ++iBit)
{
descrRev <<= 1;
descrRev |= descr & 1;
descr >>= 1;
}
return descrRev;
}
static void buildMat(int n, float mat[], uint32_t descr)
{
int iDiag;
for (iDiag = 1 - n; iDiag < 0; ++iDiag)
{
float val = static_cast<float>(descr & 1);
descr >>= 1;
for (int iRow = 0; iRow < n + iDiag; ++iRow)
{
mat[iRow * (n + 1) - iDiag] = val;
}
}
for ( ; iDiag < n; ++iDiag)
{
float val = static_cast<float>(descr & 1);
descr >>= 1;
for (int iCol = 0; iCol < n - iDiag; ++iCol)
{
mat[iCol * (n + 1) + iDiag * n] = val;
}
}
}
static float determinant(int n, float mat[])
{
float det = 1.0f;
for (int k = 0; k < n - 1; ++k)
{
float maxVal = 0.0f;
int pk = 0;
for (int i = k; i < n; ++i)
{
float q = absVal(mat[i * n + k]);
if (q > maxVal)
{
maxVal = q;
pk = i;
}
}
if (pk != k)
{
det = -det;
for (int j = 0; j < n; ++j)
{
float t = mat[k * n + j];
mat[k * n + j] = mat[pk * n + j];
mat[pk * n + j] = t;
}
}
float s = mat[k * n + k];
det *= s;
s = 1.0f / s;
for (int i = k + 1; i < n; ++i)
{
mat[i * n + k] *= s;
for (int j = k + 1; j < n; ++j)
{
mat[i * n + j] -= mat[i * n + k] * mat[k * n + j];
}
}
}
det *= mat[n * n - 1];
return det;
}
static void threadBarrier()
{
pthread_mutex_lock(&ThreadMutex);
++BarrierCount;
if (BarrierCount <= ThreadCount)
{
pthread_cond_wait(&ThreadCond, &ThreadMutex);
}
else
{
pthread_cond_broadcast(&ThreadCond);
BarrierCount = 0;
}
pthread_mutex_unlock(&ThreadMutex);
}
static void* threadFunc(void* pData)
{
int* pThreadIdx = static_cast<int*>(pData);
int threadIdx = *pThreadIdx;
float* mat = new float[NMax * NMax];
for (int n = 1; n <= NMax; ++n)
{
uint32_t descrRange(1u << (2 * n - 1));
float maxDet = 0.0f;
uint32_t maxDescr = 0;
uint32_t descrInc = threadIdx;
for (uint32_t descrBase = 0;
descrBase + descrInc < descrRange;
descrBase += ThreadCount)
{
uint32_t descr = descrBase + descrInc;
descrInc = (descrInc + 1) % ThreadCount;
if (reverse(n, descr) > descr)
{
continue;
}
buildMat(n, mat, descr);
float det = determinant(n, mat);
if (det > maxDet)
{
maxDet = det;
maxDescr = descr;
}
}
MaxDetA[threadIdx] = maxDet;
MaxDescrA[threadIdx] = maxDescr;
threadBarrier();
// Let main thread output results.
threadBarrier();
}
delete[] mat;
return 0;
}
static void printMat(int n, float mat[])
{
for (int iRow = 0; iRow < n; ++iRow)
{
for (int iCol = 0; iCol < n; ++iCol)
{
std::cout << " " << mat[iRow * n + iCol];
}
std::cout << std::endl;
}
std::cout << std::endl;
}
int main(int argc, char* argv[])
{
if (argc > 1)
{
NMax = atoi(argv[1]);
if (NMax > 16)
{
NMax = 16;
}
}
if (argc > 2)
{
ThreadCount = atoi(argv[2]);
}
MaxDetA = new float[ThreadCount];
MaxDescrA = new uint32_t[ThreadCount];
pthread_mutex_init(&ThreadMutex, 0);
pthread_cond_init(&ThreadCond, 0);
int* threadIdxA = new int[ThreadCount];
pthread_t* threadA = new pthread_t[ThreadCount];
for (int iThread = 0; iThread < ThreadCount; ++iThread)
{
threadIdxA[iThread] = iThread;
pthread_create(threadA + iThread, 0, threadFunc, threadIdxA + iThread);
}
float* mat = new float[NMax * NMax];
for (int n = 1; n <= NMax; ++n)
{
threadBarrier();
float maxDet = 0.0f;
uint32_t maxDescr = 0;
for (int iThread = 0; iThread < ThreadCount; ++iThread)
{
if (MaxDetA[iThread] > maxDet)
{
maxDet = MaxDetA[iThread];
maxDescr = MaxDescrA[iThread];
}
}
std::cout << "n = " << n << " det = " << maxDet << std::endl;
buildMat(n, mat, maxDescr);
printMat(n, mat);
threadBarrier();
}
delete[] mat;
delete[] MaxDetA;
delete[] MaxDescrA;
delete[] threadIdxA;
delete[] threadA;
return 0;
}