int main(void) {
e_iap_status iap_status;
/* Fill the flash with payload and hash data */
iap_status = (e_iap_status) generator_init();
if (iap_status != CMD_SUCCESS)
while (1)
; // Error !!!
Details d;
initButton();
initDMA();
initDetails(&d, getNumberOfChunks(), getSizeOfChunk());
while (buttonIterrupt) {
}
int res = mainFunction(&d, 32);
if(res==0) {
blinkLed(1000000);
}
else {
blinkLed(100);
}
return 0;
}
/**
* constructor
*/
SellCSigma_Matrix::SellCSigma_Matrix( MMreader mmMatrix, int C, int const sigma )
:C_(C), sigma_(sigma)
,M_(mmMatrix.getRows()), N_(mmMatrix.getCols())
,nz_(mmMatrix.getNonZeros()), numberOfChunks_((M_-1)/C+1)
,colInd_(nullptr)
,chunkPtr_(new int[numberOfChunks_]), chunkLength_(new int[numberOfChunks_])
,permute_(new int[M_]), antiPermute_(new int[M_])
,val_(nullptr)
{
// sort input Matrix by row ID
if( !mmMatrix.isRowSorted() )
sortByRow(mmMatrix);
std::vector< std::tuple<int,int,double> > & mmData = mmMatrix.getMatrx();
std::vector< std::tuple<int, int> > rowLengths = getRowLengths(mmMatrix);
// sort sigam chunks by row length
auto begin = rowLengths.begin();
auto end = rowLengths.begin() + getSigma();
for (; end <= rowLengths.end(); begin += getSigma(), end += getSigma() )
{
std::sort(begin, end,
[](std::tuple<int,int> const & a, std::tuple<int,int> const & b)
{return std::get<1>(a) < std::get<1>(b);}
);
}
begin -= getSigma();
std::sort(begin, rowLengths.end(),
[](std::tuple<int,int> const & a, std::tuple<int,int> const & b)
{return std::get<1>(a) < std::get<1>(b);}
);
// determine chunk length and size
// and set backword permutation
std::vector<int> valuesPerChunk( getNumberOfChunks() );
#ifdef _OPENMP
#pragma omp parallel for schedule(runtime)
#endif
for (int chunk=0; chunk < getNumberOfChunks(); ++chunk)
{
int maxRowLenghth = 0;
for (int i=0, row=chunk*getChunkSize();
i<getChunkSize() && row<getRows();
++i, ++row
)
{
if ( maxRowLenghth < std::get<1>(rowLengths[row]) )
maxRowLenghth = std::get<1>(rowLengths[row]);
// set backword permutation
antiPermute_[ std::get<0>(rowLengths[row]) ] = row;
}
chunkLength_[chunk] = maxRowLenghth;
valuesPerChunk[chunk] = maxRowLenghth * getChunkSize();
}
// calculate memory usage and allocate memmory for values and colum IDs
capasety_ = std::accumulate(std::begin(valuesPerChunk),
std::end(valuesPerChunk),
0
);
val_ = new double[capasety_];
colInd_ = new int [capasety_];
// calulate memory overhead
overhead_ = capasety_ - getNonZeros();
// creat Sell-C-sigma data
std::vector<int> chunkOffset = getOffsets(valuesPerChunk);
std::vector<int> rowOffset = getOffsets(getValsPerRow(mmMatrix));
#ifdef _OPENMP
#pragma omp parallel for schedule(runtime)
#endif
for (int chunk=0; chunk < getNumberOfChunks(); ++chunk)
{
chunkPtr_[chunk] = chunkOffset[chunk];
for (int j=0; j<chunkLength_[chunk]; ++j)
{
for (int i=0, row=chunk*getChunkSize();
i<getChunkSize();
++i, ++row
)
{
int col;
double val;
if (row<getRows())
{
// set permutation
permute_[row] = std::get<0>(rowLengths[row]);
// finde values and collumn index
if ( j < std::get<1>(rowLengths[row]) )
{ // fill with matrix values
int id = rowOffset[ permute_[row] ] + j;
val = std::get<2>( mmData[id] );
col = std::get<1>( mmData[id] );
}
else
{ // fill chunk with 0
val = 0.;
col = 0;
}
}
else
{ // add zero rows to end of matrix fill up last chunk
val = 0.;
col = 0;
}
val_ [chunkPtr_[chunk] + i + j*getChunkSize()] = val;
colInd_[chunkPtr_[chunk] + i + j*getChunkSize()] = antiPermute_[col];
}
}
}
/*
std::cout << "Sell-C-sigma constructed:"
<< "\nC: " << getChunkSize() << " sigma: " << getSigma()
<< "\n(" << getRows() << "," << getCols() << ") " << getNonZeros()
<< ":\n";
for (int i=0; i<valueMemoryUsage; ++i)
{
std::cout << getValues()[i] << " (" << getColInd()[i] << ")\n";
}
std::cout << std::endl;
*/
}
