void MultilayerPerceptron::run()
{
vector<vector<double> >
inputs = ts->getInputs(),
targets = ts->getTargets();
StopCondition
//BP parameters
sc = (StopCondition)mlpbpts->getStopParameter();
double
//SA parameters
startCondition = 0,
To = 0,
minNoise = 0,
maxNoise = 0,
tempDecFactor = 0,
Tmin = 0,
//BP parameters
learningRate = mlpbpts->getLearningRate(),
MSEmin = mlpbpts->getMinMSE(),
RMSEmin = mlpbpts->getMinRMSE(),
CEmin = mlpbpts->getMinCE();
unsigned int
//SA parameters
nChanges = 0,
//BP parameters
epochs = mlpbpts->getMaxEpochs();
if(sa){
startCondition = mlpsats->getLocalMinimumCondition();
To = mlpsats->getTo();
minNoise = mlpsats->getMinNoise();
maxNoise = mlpsats->getMaxNoise();
tempDecFactor = mlpsats->getTempDecrementFactor();
Tmin = mlpsats->getMinTemperature();
nChanges = mlpsats->getChanges();
}
size_t
nPatterns,
nNeurons,
nBOutputs,
nOutputs;
vector<double>
yObtained,
deltaOut(outputWeights.size(), 0);
// vector<vector<double> > deltaHidden(layerWeights.size());
deltaHidden.resize(layerWeights.size());
for(size_t i = 0; i < deltaHidden.size(); i++){
size_t sLayer = layerWeights[i].size();
deltaHidden[i].resize(sLayer, 0);
}
nPatterns = inputs.size();
int nLayers = int(layerWeights.size());
double pMSE;
// unsigned long epc;
double sumDeltas;
nOutputs = getOutputSize();
// MultilayerPerceptron::TrainingResult tr;
tres->time = 0;
tres->epochs = 0;
tres->MSEHistory.clear();
tres->MSE = getMSE(inputs, targets);
tres->MSEHistory.push_back(tres->MSE);
tres->RMSEHistory.clear();
tres->RMSE = getRMSE(inputs, targets);
tres->RMSEHistory.push_back(tres->RMSE);
tres->CEHistory.clear();
tres->CE = getCE(inputs, targets);
tres->CEHistory.push_back(tres->CE);
// tres.layerWeightsHistory.clear();
// tres.layerWeightsHistory.push_back(layerWeights);
// tres.outputWeightsHistory.clear();
// tres.outputWeightsHistory.push_back(outputWeights);
vector<vector<double> > layerOutputs;
long double
T = 0,
sumDeltaF = 0,
deltaF = 0,
Pa = 0,
avgDeltaF = 0;
int c = 0;
training = true;
clock_t t_ini = clock();
do{
// tr.MSE = 0;
// pMSE = 0;
for(size_t p = 0; p < nPatterns; p++){
//Se obtienen las salidas para cada una de las capas
layerOutputs = getLayerOutputs(inputs[p]);
yObtained = layerOutputs[layerOutputs.size() - 1];
for(int layer = nLayers; layer >= 0; layer--){
nNeurons = (layer == nLayers ? outputWeights.size() : layerWeights[layer].size());
// deltaOut = vector<double>(nNeurons, 0);
for(size_t neuron = 0; neuron <= nNeurons; neuron++){
//Se inicia el calculo de todos los deltas
if(layer == nLayers){ //Si es la capa de salida
if(neuron < nNeurons){
switch(tf){
case Sigmoid:
deltaOut[neuron] = alfa * yObtained[neuron] * (1 - yObtained[neuron]) * (targets[p][neuron] - yObtained[neuron]);
break;
case Tanh:
deltaOut[neuron] = alfa * (1 - (yObtained[neuron]*yObtained[neuron])) * (targets[p][neuron] - yObtained[neuron]);
break;
}
}else{
continue;
}
}else{
size_t nDeltaElements = (layer == nLayers - 1 ? outputWeights.size() : layerWeights[layer + 1].size());
sumDeltas = 0;
for(size_t element = 0; element < nDeltaElements; element++){
if(layer == nLayers - 1){
sumDeltas += deltaOut[element] * outputWeights[element][neuron];
}else{
sumDeltas += deltaHidden[layer+1][element] * layerWeights[layer+1][element][neuron];
}
}
switch(tf){
case Sigmoid:
deltaHidden[layer][neuron] = alfa * layerOutputs[layer][neuron] * (1 - layerOutputs[layer][neuron]) * sumDeltas;
break;
case Tanh:
deltaHidden[layer][neuron] = alfa * (1 - (layerOutputs[layer][neuron]*layerOutputs[layer][neuron])) * sumDeltas;
break;
}
}
}
}
//Comienza la actualizacion de los pesos
for(int layer = nLayers; layer >= 0; layer--){
nNeurons = (layer == nLayers ? nOutputs : layerWeights[layer].size());
for(size_t i = 0; i < nNeurons; i++){
nBOutputs = (layer == 0 ? inputs[p].size() : layerWeights[layer - 1].size());
for(size_t j = 0; j <= nBOutputs; j++){
if(layer == nLayers){
outputWeights[i][j] += (j == nBOutputs ? -learningRate*deltaOut[i] : learningRate*deltaOut[i]*layerOutputs[layer-1][j]);
}else if(layer == 0){
layerWeights[layer][i][j] += (j == nBOutputs ?
-learningRate*deltaHidden[layer][i] :
learningRate*deltaHidden[layer][i]*inputs[p][j]);
}else{
layerWeights[layer][i][j] += (j == nBOutputs ? -learningRate*deltaHidden[layer][i] : learningRate*deltaHidden[layer][i]*layerOutputs[layer-1][j]);
}
}
}
}
}
pMSE = getMSE(inputs, targets);
if(sa){//if Simulated annealing activated
deltaF = pMSE - tres->MSE;
sumDeltaF += deltaF; // Se calcula deltaF promedio
c++;
avgDeltaF = sumDeltaF / c;
}
tres->MSE = pMSE;
tres->MSEHistory.push_back(tres->MSE);
tres->RMSE = getRMSE(inputs, targets);
tres->RMSEHistory.push_back(tres->RMSE);
tres->CE = getCE(inputs, targets);
tres->CEHistory.push_back(tres->CE);
// tr.layerWeightsHistory.push_back(layerWeights);
// tr.outputWeightsHistory.push_back(outputWeights);
// epc++;
if(sa){
if(fabs(avgDeltaF) < startCondition && c > 999){
// double avgDeltaF = sumDeltaF / c;
// T = avgDeltaF / log(initialAcceptance);
// T = 1 / log(initialAcceptance) * avgDeltaF;
// T = deltaF / log(Pa);
// T = -deltaF;
// T = To;
T = To;
double fNew;
NewState ns;
// int n = 0;
double fOld = tres->MSE;
double rnd = 0;
do{
for(unsigned int i = 0; i < nChanges; i++){
ns = addNoise(minNoise, maxNoise);
fNew = getNewMSE(ns.newWeights, ns.newOutputWeights, inputs, targets);
deltaF = fNew - fOld;
Pa = exp(-deltaF/T);
rnd = randomNumber(0,1);
if(deltaF < 0
|| rnd < Pa
){
layerWeights = ns.newWeights;
outputWeights = ns.newOutputWeights;
fOld = getMSE(inputs, targets);
}
}
// T = T / (1 + n);
T = tempDecFactor*T;
// n++;
}while(T > Tmin);
c = 0;
sumDeltaF = 0;
}
}
tres->epochs++;
}while(((tres->MSE >= MSEmin && sc == MSE) ||
(tres->RMSE >= RMSEmin && sc == RMSE) ||
(tres->CE >= CEmin && sc == CE)) &&
tres->epochs < epochs &&
training);
training = false;
tres->time = double(clock() - t_ini)/CLOCKS_PER_SEC;
}
ValueCell::ValueCell( int x, int y ) : CellBase(x,y), my_value(randomNumber(MINVAL, MAXVAL)) { }
struct SVAThread *
findNextFreeThread (void) {
for (unsigned int index = 0; index < 4096; ++index) {
if (__sync_bool_compare_and_swap (&(Threads[index].used), 0, 1)) {
/*
* Remember which thread is the one we've grabbed.
*/
struct SVAThread * newThread = Threads + index;
/*
* Do some basic initialization of the thread.
*/
newThread->integerState.valid = 0;
newThread->savedICIndex = 0;
newThread->ICFPIndex = 0;
newThread->secmemSize = 0;
newThread->numPushTargets = 0;
newThread->secmemPML4e = 0;
/*
* This function currently sets the thread secret with a default
* statically defined key. However, in the future will obtain said key
* from the executable image. There is also some issue with
* bootstrapping the initial key and whether or not on the first
* execution of an application the key will need to be generated by SVA.
* Thus, future design is yet to be done, however, the following function
* should suffice to enable any of the above scenarios.
*
* TODO: The function currently uses a dummy static key, but in the
* future will obtain the key from the executable image and then
* decrypted with the VirtualGhost private key.
*/
if (vg) {
init_thread_key(newThread);
}
#if DEBUG
printf("<<<< SVA: Created new private key: value: %s\n",
newThread->secret.key);
#endif
/*
* Use the next-to-last interrupt context in the list as the first
* interrupt context. This may be slightly wasteful, but it's a little
* easier to make it work correctly right now.
*
* The processor's IST3 field should be configured so that the next
* interrupt context is at maxIC - 2.
*/
sva_icontext_t * icontextp = newThread->interruptContexts + maxIC - 1;
newThread->integerState.ist3 = ((uintptr_t) icontextp) - 0x10;
newThread->integerState.kstackp = newThread->integerState.ist3;
/*
* Generate a random identifier for the new thread.
*/
if (vg) {
newThread->rid = randomNumber();
}
return newThread;
}
}
panic ("SVA: findNextFreeThread: Exhausted SVA Threads!\n");
return 0;
}
int test_prod(Epsilon const& epsilon)
{
int ret;
viennacl::tools::uniform_random_numbers<NumericT> randomNumber;
std::size_t matrix_size1 = 29; //some odd number, not too large
std::size_t matrix_size2 = 47; //some odd number, not too large
std::size_t matrix_size3 = 33; //some odd number, not too large
//std::size_t matrix_size1 = 128; //some odd number, not too large
//std::size_t matrix_size2 = 64; //some odd number, not too large
//std::size_t matrix_size3 = 128; //some odd number, not too large
//std::size_t matrix_size1 = 256; // for testing AMD kernels
//std::size_t matrix_size2 = 256; // for testing AMD kernels
//std::size_t matrix_size3 = 256; // for testing AMD kernels
// --------------------------------------------------------------------------
// ublas reference:
std::vector<std::vector<NumericT> > A(matrix_size1, std::vector<NumericT>(matrix_size2));
std::vector<std::vector<NumericT> > big_A(4*matrix_size1, std::vector<NumericT>(4*matrix_size2, NumericT(3.1415)));
std::vector<std::vector<NumericT> > B(matrix_size2, std::vector<NumericT>(matrix_size3));
std::vector<std::vector<NumericT> > big_B(4*matrix_size2, std::vector<NumericT>(4*matrix_size3, NumericT(42.0)));
std::vector<std::vector<NumericT> > C(matrix_size1, std::vector<NumericT>(matrix_size3));
//fill A and B:
for (std::size_t i = 0; i < A.size(); ++i)
for (std::size_t j = 0; j < A[0].size(); ++j)
A[i][j] = static_cast<NumericT>(0.1) * randomNumber();
for (std::size_t i = 0; i < B.size(); ++i)
for (std::size_t j = 0; j < B[0].size(); ++j)
B[i][j] = static_cast<NumericT>(0.1) * randomNumber();
std::vector<std::vector<NumericT> > A_trans(A[0].size(), std::vector<NumericT>(A.size()));
for (std::size_t i = 0; i < A.size(); ++i)
for (std::size_t j = 0; j < A[0].size(); ++j)
A_trans[j][i] = A[i][j];
std::vector<std::vector<NumericT> > big_A_trans(big_A[0].size(), std::vector<NumericT>(big_A.size()));
for (std::size_t i = 0; i < big_A.size(); ++i)
for (std::size_t j = 0; j < big_A[0].size(); ++j)
big_A_trans[j][i] = big_A[i][j];
std::vector<std::vector<NumericT> > B_trans(B[0].size(), std::vector<NumericT>(B.size()));
for (std::size_t i = 0; i < B.size(); ++i)
for (std::size_t j = 0; j < B[0].size(); ++j)
B_trans[j][i] = B[i][j];
std::vector<std::vector<NumericT> > big_B_trans(big_B[0].size(), std::vector<NumericT>(big_B.size()));
for (std::size_t i = 0; i < big_B.size(); ++i)
for (std::size_t j = 0; j < big_B[0].size(); ++j)
big_B_trans[j][i] = big_B[i][j];
//
// ViennaCL objects
//
// A
viennacl::range range1_A(matrix_size1, 2*matrix_size1);
viennacl::range range2_A(matrix_size2, 2*matrix_size2);
viennacl::slice slice1_A(matrix_size1, 2, matrix_size1);
viennacl::slice slice2_A(matrix_size2, 3, matrix_size2);
viennacl::matrix<NumericT, F_A> vcl_A(matrix_size1, matrix_size2);
viennacl::copy(A, vcl_A);
viennacl::matrix<NumericT, F_A> vcl_big_range_A(4*matrix_size1, 4*matrix_size2);
viennacl::matrix_range<viennacl::matrix<NumericT, F_A> > vcl_range_A(vcl_big_range_A, range1_A, range2_A);
viennacl::copy(A, vcl_range_A);
viennacl::matrix<NumericT, F_A> vcl_big_slice_A(4*matrix_size1, 4*matrix_size2);
viennacl::matrix_slice<viennacl::matrix<NumericT, F_A> > vcl_slice_A(vcl_big_slice_A, slice1_A, slice2_A);
viennacl::copy(A, vcl_slice_A);
// A^T
viennacl::matrix<NumericT, F_A> vcl_A_trans(matrix_size2, matrix_size1);
viennacl::copy(A_trans, vcl_A_trans);
viennacl::matrix<NumericT, F_A> vcl_big_range_A_trans(4*matrix_size2, 4*matrix_size1);
viennacl::matrix_range<viennacl::matrix<NumericT, F_A> > vcl_range_A_trans(vcl_big_range_A_trans, range2_A, range1_A);
viennacl::copy(A_trans, vcl_range_A_trans);
viennacl::matrix<NumericT, F_A> vcl_big_slice_A_trans(4*matrix_size2, 4*matrix_size1);
viennacl::matrix_slice<viennacl::matrix<NumericT, F_A> > vcl_slice_A_trans(vcl_big_slice_A_trans, slice2_A, slice1_A);
viennacl::copy(A_trans, vcl_slice_A_trans);
// B
viennacl::range range1_B(2*matrix_size2, 3*matrix_size2);
viennacl::range range2_B(2*matrix_size3, 3*matrix_size3);
viennacl::slice slice1_B(matrix_size2, 3, matrix_size2);
viennacl::slice slice2_B(matrix_size3, 2, matrix_size3);
viennacl::matrix<NumericT, F_B> vcl_B(matrix_size2, matrix_size3);
viennacl::copy(B, vcl_B);
viennacl::matrix<NumericT, F_B> vcl_big_range_B(4*matrix_size2, 4*matrix_size3);
viennacl::matrix_range<viennacl::matrix<NumericT, F_B> > vcl_range_B(vcl_big_range_B, range1_B, range2_B);
viennacl::copy(B, vcl_range_B);
viennacl::matrix<NumericT, F_B> vcl_big_slice_B(4*matrix_size2, 4*matrix_size3);
viennacl::matrix_slice<viennacl::matrix<NumericT, F_B> > vcl_slice_B(vcl_big_slice_B, slice1_B, slice2_B);
viennacl::copy(B, vcl_slice_B);
// B^T
viennacl::matrix<NumericT, F_B> vcl_B_trans(matrix_size3, matrix_size2);
viennacl::copy(B_trans, vcl_B_trans);
viennacl::matrix<NumericT, F_B> vcl_big_range_B_trans(4*matrix_size3, 4*matrix_size2);
viennacl::matrix_range<viennacl::matrix<NumericT, F_B> > vcl_range_B_trans(vcl_big_range_B_trans, range2_B, range1_B);
viennacl::copy(B_trans, vcl_range_B_trans);
viennacl::matrix<NumericT, F_B> vcl_big_slice_B_trans(4*matrix_size3, 4*matrix_size2);
viennacl::matrix_slice<viennacl::matrix<NumericT, F_B> > vcl_slice_B_trans(vcl_big_slice_B_trans, slice2_B, slice1_B);
viennacl::copy(B_trans, vcl_slice_B_trans);
// C
viennacl::range range1_C(matrix_size1-1, 2*matrix_size1-1);
viennacl::range range2_C(matrix_size3-1, 2*matrix_size3-1);
viennacl::slice slice1_C(matrix_size1-1, 3, matrix_size1);
viennacl::slice slice2_C(matrix_size3-1, 3, matrix_size3);
viennacl::matrix<NumericT, F_C> vcl_C(matrix_size1, matrix_size3);
viennacl::matrix<NumericT, F_C> vcl_big_range_C(4*matrix_size1, 4*matrix_size3);
viennacl::matrix_range<viennacl::matrix<NumericT, F_C> > vcl_range_C(vcl_big_range_C, range1_C, range2_C);
viennacl::matrix<NumericT, F_C> vcl_big_slice_C(4*matrix_size1, 4*matrix_size3);
viennacl::matrix_slice<viennacl::matrix<NumericT, F_C> > vcl_slice_C(vcl_big_slice_C, slice1_C, slice2_C);
std::cout << "--- Part 1: Testing matrix-matrix products ---" << std::endl;
//////
////// A: matrix
//////
//
//
std::cout << "Now using A=matrix, B=matrix, C=matrix" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_A, vcl_A_trans,
vcl_B, vcl_B_trans,
vcl_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=matrix, B=matrix, C=range" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_A, vcl_A_trans,
vcl_B, vcl_B_trans,
vcl_range_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=matrix, B=matrix, C=slice" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_A, vcl_A_trans,
vcl_B, vcl_B_trans,
vcl_slice_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=matrix, B=range, C=matrix" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_A, vcl_A_trans,
vcl_range_B, vcl_range_B_trans,
vcl_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=matrix, B=range, C=range" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_A, vcl_A_trans,
vcl_range_B, vcl_range_B_trans,
vcl_range_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=matrix, B=range, C=slice" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_A, vcl_A_trans,
vcl_range_B, vcl_range_B_trans,
vcl_slice_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=matrix, B=slice, C=matrix" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_A, vcl_A_trans,
vcl_slice_B, vcl_slice_B_trans,
vcl_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=matrix, B=slice, C=range" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_A, vcl_A_trans,
vcl_slice_B, vcl_slice_B_trans,
vcl_range_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=matrix, B=slice, C=slice" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_A, vcl_A_trans,
vcl_slice_B, vcl_slice_B_trans,
vcl_slice_C);
if (ret != EXIT_SUCCESS)
return ret;
//////
////// A: range
//////
//
//
std::cout << "Now using A=range, B=matrix, C=matrix" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_range_A, vcl_range_A_trans,
vcl_B, vcl_B_trans,
vcl_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=range, B=matrix, C=range" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_range_A, vcl_range_A_trans,
vcl_B, vcl_B_trans,
vcl_range_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=range, B=matrix, C=slice" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_range_A, vcl_range_A_trans,
vcl_B, vcl_B_trans,
vcl_slice_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=range, B=range, C=matrix" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_range_A, vcl_range_A_trans,
vcl_range_B, vcl_range_B_trans,
vcl_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=range, B=range, C=range" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_range_A, vcl_range_A_trans,
vcl_range_B, vcl_range_B_trans,
vcl_range_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=range, B=range, C=slice" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_range_A, vcl_range_A_trans,
vcl_range_B, vcl_range_B_trans,
vcl_slice_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=range, B=slice, C=matrix" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_range_A, vcl_range_A_trans,
vcl_slice_B, vcl_slice_B_trans,
vcl_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=range, B=slice, C=range" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_range_A, vcl_range_A_trans,
vcl_slice_B, vcl_slice_B_trans,
vcl_range_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=range, B=slice, C=slice" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_range_A, vcl_range_A_trans,
vcl_slice_B, vcl_slice_B_trans,
vcl_slice_C);
if (ret != EXIT_SUCCESS)
return ret;
//////
////// A: slice
//////
//
//
std::cout << "Now using A=slice, B=matrix, C=matrix" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_slice_A, vcl_slice_A_trans,
vcl_B, vcl_B_trans,
vcl_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=slice, B=matrix, C=range" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_slice_A, vcl_slice_A_trans,
vcl_B, vcl_B_trans,
vcl_range_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=slice, B=matrix, C=slice" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_slice_A, vcl_slice_A_trans,
vcl_B, vcl_B_trans,
vcl_slice_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=slice, B=range, C=matrix" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_slice_A, vcl_slice_A_trans,
vcl_range_B, vcl_range_B_trans,
vcl_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=slice, B=range, C=range" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_slice_A, vcl_slice_A_trans,
vcl_range_B, vcl_range_B_trans,
vcl_range_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=slice, B=range, C=slice" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_slice_A, vcl_slice_A_trans,
vcl_range_B, vcl_range_B_trans,
vcl_slice_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=slice, B=slice, C=matrix" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_slice_A, vcl_slice_A_trans,
vcl_slice_B, vcl_slice_B_trans,
vcl_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=slice, B=slice, C=range" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_slice_A, vcl_slice_A_trans,
vcl_slice_B, vcl_slice_B_trans,
vcl_range_C);
if (ret != EXIT_SUCCESS)
return ret;
//
//
std::cout << "Now using A=slice, B=slice, C=slice" << std::endl;
ret = test_prod<NumericT>(epsilon,
A, A_trans, B, B_trans, C,
vcl_slice_A, vcl_slice_A_trans,
vcl_slice_B, vcl_slice_B_trans,
vcl_slice_C);
if (ret != EXIT_SUCCESS)
return ret;
return ret;
}
// Returns a random delay in units of 0.922 ms (the same units of radioMacRx).
// This is used to decide when to next transmit a queued data packet.
static uint8 randomTxDelay()
{
return 1 + (randomNumber() & 3);
}
void planarTriconnectedGraph(Graph &G, int n, double p1, double p2)
{
if (n < 4) n = 4;
// start with K_4
completeGraph(G,4);
planarEmbedPlanarGraph(G);
// nodes[0],...,nodes[i-1] is array of all nodes
Array<node> nodes(n);
node v;
int i = 0;
forall_nodes(v,G)
nodes[i++] = v;
for(; i < n; ++i)
{
// pick a random node
v = nodes[randomNumber(0,i-1)];
int m = v->degree();
int a1 = randomNumber(0,m-1);
int a2 = randomNumber(0,m-2);
int j;
adjEntry adj1, adj2;
for(adj1 = v->firstAdj(), j = 0; j < a1; adj1 = adj1->succ(), ++j) ;
for(adj2 = adj1->cyclicSucc(), j = 0; j < a2; adj2 = adj2->cyclicSucc(), ++j) ;
adjEntry adj_b1 = adj2->cyclicPred();
adjEntry adj_b2 = adj1->cyclicPred();
nodes[i] = G.splitNode(adj1, adj2);
if(adj1 == adj_b1)
G.newEdge(adj_b1, adj2->twin());
else if(adj2 == adj_b2)
G.newEdge(adj2, adj_b1->twin(), ogdf::before);
else {
double r = randomDouble(0.0,1.0);
if(r <= p1) {
int s = randomNumber(0,1);
if(s == 0)
G.newEdge(adj_b1, adj2->twin());
else
G.newEdge(adj2, adj_b1->twin(), ogdf::before);
}
}
double r = randomDouble(0.0,1.0);
if(r <= p2) {
int s = randomNumber(0,1);
if(s == 0)
G.newEdge(adj1, adj_b2->twin(), ogdf::before);
else
G.newEdge(adj_b2, adj1->twin());
}
}
}
void planarConnectedGraph(Graph &G, int n, int m)
{
if (n < 1) n = 1;
if (m < n-1) m = n-1;
if (m > 3*n-6) m = 3*n-6;
G.clear();
Array<node> nodes(n);
// we start with a triangle
nodes[0] = G.newNode();
//build tree
int i;
for(i=1; i<n; ++i) {
node on = nodes[randomNumber(0,i-1)];
node nn = nodes[i] = G.newNode();
G.firstNode()->degree();
if(on->degree() > 1) {
adjEntry adj = on->firstAdj();
for(int fwd = randomNumber(0,on->degree()-1); fwd>0; --fwd)
adj = adj->succ();
G.newEdge(nn, adj);
} else {
G.newEdge(nn, on);
}
}
List<face> bigFaces; // not a triangle
CombinatorialEmbedding E(G);
bigFaces.pushBack(E.firstFace());
for(i = m-n+1; i-->0;) {
ListIterator<face> fi = bigFaces.chooseIterator();
face f = *fi;
bigFaces.del(fi);
List<adjEntry> fnodes;
adjEntry adj;
forall_face_adj(adj, f) {
fnodes.pushBack(adj);
}
fnodes.permute();
adjEntry adj1,adj2;
bool okay = false;
do {
adj1 = fnodes.popFrontRet();
node n1 = adj1->theNode();
forall_listiterators(adjEntry, it, fnodes) {
adj2 = *it;
node n2 = adj2->theNode();
if(n1==n2 || adj1->faceCyclePred() == adj2 || adj2->faceCyclePred() == adj1) {
continue;
}
edge e;
okay = true;
forall_adj_edges(e,n1) {
if(e->opposite(n1) == n2) {
okay = false;
break;
}
}
if(okay) break;
}
} while(!okay);
edge ne = E.splitFace(adj1,adj2);
face f1 = E.rightFace(ne->adjSource());
face f2 = E.rightFace(ne->adjTarget());
if (f1->size() > 3) bigFaces.pushBack(f1);
if (f2->size() > 3) bigFaces.pushBack(f2);
}
it("supports 3D", [&]() {
GraphAttributes attr(*graph,
GraphAttributes::nodeGraphics |
GraphAttributes::nodeStyle |
GraphAttributes::edgeGraphics |
GraphAttributes::threeD |
GraphAttributes::nodeLabel |
GraphAttributes::nodeLabelPosition);
List<node> nodes;
graph->allNodes(nodes);
nodes.permute();
int i = 0;
for(node v : nodes) {
attr.fillColor(v) = Color::Name::Gray;
attr.x(v) = randomNumber(0, numberOfNodes*5);
attr.y(v) = randomNumber(0, numberOfNodes*5);
attr.label(v) = to_string(i);
attr.z(v) = i++;
}
List<int> expected;
for(i = 0; i < numberOfNodes; i++) {
expected.pushBack(i);
}
pugi::xml_document doc;
createDocument(attr, doc);
pugi::xpath_node_set xmlNodes = doc.select_nodes("//text");
AssertThat(static_cast<int>(xmlNodes.size()), Equals(graph->numberOfNodes()));
int main(int args, char *argv[]) {
char message[100];
MainPlayerData toPlayerData;
CandidateData toCandidateData;
StatusType status;
fd_set allSocket;
fd_set readfds;
int fdmax, k, l;
int n;
int playerIndex;
int mainPlayerSelected = 0;
int clientId;
int playerAnswer;
int level;
int numberOfClient = 0;
int yes = 1;
int readResult;
int listener;
int acceptSocket;
struct sockaddr_in server, client;
int sin_size;
int socket_in_allSocket;
int nbytes;
int i, j;
char clientName[40];
initializeClientList();
createCashPrizeList();
sin_size = sizeof(struct sockaddr_in);
FD_ZERO(&allSocket);
FD_ZERO(&readfds);
if (args < 2) {
printf("Usage : %s <PORT>\n", argv[0]);
exit(-1);
}
readResult = readQuestionFile("question.txt");
if (readResult < 0) {
printf("Can't load the questions !");
exit(-1);
}
if ((listener = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("socket() error!\n");
exit(-1);
}
server.sin_family = AF_INET;
server.sin_port = htons(atoi(argv[1]));
server.sin_addr.s_addr = INADDR_ANY;
bzero(&(server.sin_zero), 8);
setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
if (bind(listener, (struct sockaddr*) &server, sizeof(struct sockaddr))
== -1) {
printf("bind() error!\n");
exit(-1);
}
//listen
if (listen(listener, 2) == -1) {
perror("listen");
exit(3);
}
FD_SET(listener, &allSocket);
fdmax = listener;
printf("\t<<<Gameshow GHE NONG - AI LA TRIEU PHU>>>\n");
while (1) {
readfds = allSocket;
/* On error, -1 is returned, select() and pselect() return the number of file descriptors */
if (mainPlayerSelected == 0) {
if (select(fdmax + 1, &readfds, NULL, NULL, NULL ) == -1) {
perror("select");
printf("errno = %d.\n", errno);
exit(4);
}
}
for (i = 0; i <= fdmax; i++) {
if (FD_ISSET(i, &readfds)) {
//printf("isset i=%d\n", i);
if (i == listener) {
acceptSocket = accept(listener, (struct sockaddr*) &client,
&sin_size);
printf("Listener : %d accept %d\n", listener, acceptSocket);
//in dia chi ip
printf("\n client address %s\n",
inet_ntoa(client.sin_addr));
if (acceptSocket == -1) {
perror("accept");
} else if (isClientListFull()) {
clientId = NULL_ID;
send(acceptSocket, &clientId, sizeof clientId, 0);
close(acceptSocket);
//FD_CLR(acceptSocket, &allSocket);
} else {
FD_SET(acceptSocket, &allSocket);
printf("Server connected with socket %d\n",
acceptSocket);
addClient(acceptSocket);
clientId = acceptSocket;
if (acceptSocket > fdmax) {
fdmax = acceptSocket;
//printf("Now fdmax is : %d\n", fdmax);
}
send(acceptSocket, &clientId, sizeof clientId, 0);
numberOfClient = getNumberOfClient();
printf("We're now having %d clients connected !\n",
numberOfClient);
}
} else {
// printf("i before switch = %d Fmax=%d\n", i, fdmax);
switch_case: switch (getClientStatus(i)) {
case CONNECTED:
if ((nbytes = recv(i, &toCandidateData,
sizeof toCandidateData, 0)) <= 0) {
printf(
"Server stopped connecting to client id %d\n",
i);
close(i);
removeClient(i);
printf("%d clients left !\n", getNumberOfClient());
FD_CLR(i, &allSocket);
break;
} else {
recv(i, clientName, sizeof clientName, 0);
setClientStatus(i, WAITING, clientName);
strcpy(message, "Welcome : ");
strcat(message, clientName);
strcat(message, "\n");
strcpy(toCandidateData.message, message);
toCandidateData.status = WAITING;
send(i, &toCandidateData, sizeof toCandidateData,
0);
printClientList();
/* check if have enough 6 clients, so we can start the game */
if (readyToStart()) {
printf("We can start the game !!\n");
k = randomNumber(NUMBERS_PER_QUES);
//send question to all the clients //
for (j = 0; j < BACKLOG; j++) {
setCompetition(j);
copyQuestion(&(toCandidateData.question),
questLib[0][k]);
toCandidateData.ansTime = 0;
toCandidateData.status = COMPETING;
strcpy(toCandidateData.message,
QUICK_QUESTION_MESSAGE);
send(clientInfo[j].id, &toCandidateData,
sizeof(CandidateData), 0);
}
//get the answer back from them //
for (j = 0; j < BACKLOG; j++) {
if (recv(clientInfo[j].id, &toCandidateData,
sizeof toCandidateData, 0) <= 0) {
printf(
"Server stopped connecting to client id %d\n",
i);
close(i);
removeClient(i);
printf("%d clients left !\n",
getNumberOfClient());
FD_CLR(i, &allSocket);
} else {
clientInfo[j].quick_answer =
toCandidateData.answer;
clientInfo[j].ansTime =
toCandidateData.ansTime;
}
}
//printf("Sending question done!\n");
printClientsAnswerList();
//select the main player //
playerIndex = selectMainPlayer(questLib[0][k],
BACKLOG);
printf(
"Our answer for the quick question : %d\n",
questLib[0][k].ans);
printf("====MAIN PLAYER SELECTED : %s ====\n",
clientInfo[playerIndex].clientName);
printClientStatus(clientInfo[playerIndex].id);
startGame(playerIndex);
for (j = 0; j < BACKLOG; j++) {
if (j != playerIndex) {
strcpy(toCandidateData.message,
JOINER_MESSAGE);
} else {
strcpy(toCandidateData.message,
MAIN_PLAYER_SELECTED);
strcpy(toPlayerData.name,
clientInfo[j].clientName);
}
toCandidateData.status = getClientStatus(
clientInfo[j].id);
send(clientInfo[j].id, &toCandidateData,
sizeof(CandidateData), 0);
}
printClientList();
//printf("Current i = %d\n", i);
i = clientInfo[playerIndex].id;
mainPlayerSelected = 1;
goto switch_case;
// break;
} else {
sprintf(message,
"We now have %d players online, please wait until we have more %d client(s) !\n",
getNumberOfClient(),
BACKLOG - getNumberOfClient());
strcpy(toCandidateData.message, message);
send(i, &toCandidateData,
sizeof toCandidateData, 0);
}
}
break;
case JOINING:
//printf("[JOINING] Current i = %d\n", i);
// i = 0;
// if (mainPlayerSelected == 1) {
// if ((nbytes = recv(i, &toCandidateData,
// sizeof toCandidateData, 0)) <= 0) {
// printf(
// "Server stopped connecting to client id %d\n",
// i);
// close(i);
// removeClient(i);
// printf("%d clients left !\n",
// getNumberOfClient());
// FD_CLR(i, &allSocket);
// break;
// }
// }
break;
case PLAYING:
mainPlayerSelected = 1;
initializeMainPlayerData(&toPlayerData);
level = 1;
do {
selectQuestion(level, &toPlayerData);
send(clientInfo[playerIndex].id, &toPlayerData,
sizeof toPlayerData, 0);
for (n = 0; n < BACKLOG; n++) {
if (clientInfo[n].status == JOINING) {
send(clientInfo[n].id, &toPlayerData,
sizeof toPlayerData, 0);
}
}
if (recv(i, &playerAnswer, sizeof playerAnswer, 0)
<= 0) {
printf(
"Server stopped connecting to client id %d\n",
i);
close(i);
removeClient(i);
printf("%d clients left !\n",
getNumberOfClient());
FD_CLR(i, &allSocket);
gameFinish(&toPlayerData,END);
for (n = 0; n < BACKLOG; n++) {
if (clientInfo[n].status == JOINING) {
toPlayerData.status = FINISHED;
send(clientInfo[n].id, &toPlayerData,
sizeof toPlayerData, 0);
close(clientInfo[n].id);
removeClient(clientInfo[n].id);
FD_CLR(clientInfo[n].id, &allSocket);
}
}
continue;
}
if (playerAnswer == RIGHT) {
printf("Good job! The player gave a right answer!\n");
increaseQuestion(&toPlayerData);
//tra loi dung o cau hoi so 15
if (level == MAX_LEVEL) {
wonGame(&toPlayerData);
send(i, &toPlayerData, sizeof toPlayerData,
0);
for (n = 0; n < BACKLOG; n++) {
if (clientInfo[n].status == JOINING) {
send(clientInfo[n].id,
&toPlayerData,
sizeof toPlayerData, 0);
close(clientInfo[n].id);
removeClient(clientInfo[n].id);
FD_CLR(clientInfo[n].id,
&allSocket);
}
}
close(i);
removeClient(i);
FD_CLR(i, &allSocket);
exit(1);
}
level = level + 1;
} else {
endGame(&toPlayerData, playerAnswer);
gameFinish(&toPlayerData,playerAnswer);
send(i, &toPlayerData, sizeof toPlayerData, 0);
for (n = 0; n < BACKLOG; n++) {
if (clientInfo[n].status == JOINING) {
toPlayerData.status = FINISHED;
send(clientInfo[n].id, &toPlayerData,
sizeof toPlayerData, 0);
close(clientInfo[n].id);
removeClient(clientInfo[n].id);
FD_CLR(clientInfo[n].id, &allSocket);
}
}
close(i);
removeClient(i);
printf("%d clients left !\n",
getNumberOfClient());
FD_CLR(i, &allSocket);
}
} while (playerAnswer == RIGHT && level <= MAX_LEVEL);
printf("The game of player : %s ended !\n",
toPlayerData.name);
exit(1);
break;
default:
break;
}
}
}
}
}
}
/** Generate full table. */
void generateTable() {
int i;
long base, addT, altT, lastT;
long checkSum = 0;
/* larger trials (n=262144 to 2097152) if desired. */
/* Trials */
int MAX_SIZE = 1048576;
int NUM_TRIALS = 10000;
n = 256;
while (n <= MAX_SIZE) {
int *n1, *n2, *sum, *copy1, *copy2;
printf ("Trying %d...\n", n);
/* generate numbers and space for storage */
n1 = calloc (n, sizeof (int));
n2 = calloc (n, sizeof (int));
randomNumber(n1);
randomNumber(n2);
sum = calloc (n+1, sizeof (int));
copy1= calloc (n, sizeof (int));
copy2= calloc (n, sizeof (int));
bcopy (n1, copy1, n);
bcopy (n2, copy2, n);
/** Timing as follows:
*
* gettimeofday(&before, (struct timezone *) NULL); BEGIN
* OP HERE
* gettimeofday(&after, (struct timezone *) NULL); END
*
* long usecs = diffTimer (&before, &after); SHOW RESULTS
* report (usecs);
*/
/* BASELINE*/
gettimeofday(&before, (struct timezone *) NULL);
for (i = 0; i < NUM_TRIALS; i++) {
int c;
/* NOP */
checkSum += n1[0];
/* circular shift (n1 left, n2 right). */
c = n1[0];
bcopy (n1+1, n1, n-1);
n1[n-1] = c;
c = n2[n-1];
bcopy (n2, n2+1, n-1);
n2[0] = c;
}
gettimeofday(&after, (struct timezone *) NULL);
base = diffTimer (&before, &after);
/* ADD */
bcopy (copy1, n1, n);
bcopy (copy2, n2, n);
gettimeofday(&before, (struct timezone *) NULL);
for (i = 0; i < NUM_TRIALS; i++) {
int c;
add(n1,n2,sum);
checkSum += sum[0];
/* circular shift (n1 left, n2 right). */
c = n1[0];
bcopy (n1+1, n1, n-1);
n1[n-1] = c;
c = n2[n-1];
bcopy (n2, n2+1, n-1);
n2[0] = c;
}
gettimeofday(&after, (struct timezone *) NULL);
addT = diffTimer (&before, &after);
/* ALT */
bcopy (copy1, n1, n);
bcopy (copy2, n2, n);
for (i = 0; i < NUM_TRIALS; i++) {
int c;
alt(n1,n2,sum);
checkSum += sum[0];
/* circular shift (n1 left, n2 right). */
c = n1[0];
bcopy (n1+1, n1, n-1);
n1[n-1] = c;
c = n2[n-1];
bcopy (n2, n2+1, n-1);
n2[0] = c;
}
gettimeofday(&after, (struct timezone *) NULL);
altT = diffTimer (&before, &after);
/* LAST */
bcopy (copy1, n1, n);
bcopy (copy2, n2, n);
gettimeofday(&before, (struct timezone *) NULL);
for (i = 0; i < NUM_TRIALS; i++) {
int c;
last(n1,n2,sum);
checkSum += sum[0];
/* circular shift (n1 left, n2 right). */
c = n1[0];
bcopy (n1+1, n1, n-1);
n1[n-1] = c;
c = n2[n-1];
bcopy (n2, n2+1, n-1);
n2[0] = c;
}
gettimeofday(&after, (struct timezone *) NULL);
lastT = diffTimer (&before, &after);
report (lastT);
printf("%d,Base:%ld,ms.\n", n, base/1000);
printf("%d,Add*:%ld,ms.\n", n, (addT-base)/1000);
printf("%d,Alt*:%ld,ms.\n", n, (altT-base)/1000);
printf("%d,Last*:%ld,ms.\n", n, (lastT-base)/1000);
/* advance */
n = n * 2;
free(n1);
free(n2);
free(copy1);
free(copy2);
free(sum);
}
printf ("Checksum:%ld\n", checkSum);
}
static RANDOM_FOREST *
train_rforest(MRI *mri_inputs[MAX_SUBJECTS][MAX_TIMEPOINTS], MRI *mri_segs[MAX_SUBJECTS][MAX_TIMEPOINTS], TRANSFORM *transforms[MAX_SUBJECTS][MAX_TIMEPOINTS],
int nsubjects, GCA *gca, RFA_PARMS *parms, float wm_thresh,
int wmsa_whalf, int ntp)
{
RANDOM_FOREST *rf ;
int nfeatures, x, y, z, ntraining, n, tvoxel_size, width, height, depth, xt, yt, zt ;
double xatlas, yatlas, zatlas ;
MRI *mri_in, *mri_seg, *mri_training_voxels, *mri_wmsa_possible ;
TRANSFORM *transform ;
double **training_data ;
int *training_classes, i, label, tlabel, nwmsa, nfuture, nnot, correct, label_time1, label_time2;
nwmsa = nnot = nfuture = 0 ;
/*
features are:
t1 intensity (3 vols)
3 priors
# of unknown voxels in the nbhd
# of neighboring wmsa voxels at t1
*/
nfeatures = parms->wsize*parms->wsize*parms->wsize*parms->nvols + 5 ;
rf = RFalloc(parms->ntrees, nfeatures, NCLASSES, parms->max_depth, single_classifier_names, max_steps) ;
if (rf == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not allocate random forest", Progname) ;
rf->min_step_size = 1 ;
tvoxel_size=1 ;
width = (int)ceil((float)mri_segs[0][0]->width/tvoxel_size) ;
height = (int)ceil((float)mri_segs[0][0]->height/tvoxel_size) ;
depth = (int)ceil((float)mri_segs[0][0]->depth/tvoxel_size) ;
mri_wmsa_possible = MRIalloc(width, height, depth, MRI_UCHAR) ;
GCAcopyDCToMRI(gca, mri_wmsa_possible) ;
mri_in = mri_inputs[0][0] ;
mri_training_voxels = MRIallocSequence(mri_in->width,mri_in->height, mri_in->depth,MRI_UCHAR,nsubjects) ;
#if 1
// update time 1 segmentation based on labels at time1 and time2
for (n = 0 ; n < nsubjects ; n++)
{
mri_seg = mri_segs[n][0] ;
for (x = 0 ; x < mri_in->width ; x++)
for (y = 0 ; y < mri_in->height ; y++)
for (z = 0 ; z < mri_in->depth ; z++)
{
label_time1 = MRIgetVoxVal(mri_segs[n][0], x, y, z, 0) ;
label_time2 = MRIgetVoxVal(mri_segs[n][1], x, y, z, 0) ;
if (IS_WMSA(label_time1))
MRIsetVoxVal(mri_segs[n][0], x, y, z, 0, label_time1) ;
else if (IS_WMSA(label_time2))
MRIsetVoxVal(mri_segs[n][0], x, y, z, 0, future_WMSA) ;
}
}
#endif
// build map of spatial locations that WMSAs can possibly occur in
for (n = 0 ; n < nsubjects ; n++)
{
mri_in = mri_inputs[n][1] ; transform = transforms[n][1] ;
for (x = 0 ; x < mri_in->width ; x++)
for (y = 0 ; y < mri_in->height ; y++)
for (z = 0 ; z < mri_in->depth ; z++)
if (is_possible_wmsa(gca, mri_in, transform, x, y, z, 0))
{
TransformSourceVoxelToAtlas(transform, mri_in, x, y, z, &xatlas, &yatlas, &zatlas) ;
xt = nint(xatlas/tvoxel_size) ;
yt = nint(yatlas/tvoxel_size) ;
zt = nint(zatlas/tvoxel_size) ;
if (xt == Gx && yt == Gy && zt == Gz)
DiagBreak() ;
MRIsetVoxVal(mri_wmsa_possible, xt, yt, zt, 0, 1) ;
}
}
for ( ; wmsa_whalf > 0 ; wmsa_whalf--)
MRIdilate(mri_wmsa_possible, mri_wmsa_possible) ;
// now build map of all voxels in training set
for (nnot = nwmsa = nfuture = ntraining = n = 0 ; n < nsubjects ; n++)
{
mri_in = mri_inputs[n][0] ; mri_seg = mri_segs[n][0] ; transform = transforms[n][0] ;
for (x = 0 ; x < mri_in->width ; x++)
for (y = 0 ; y < mri_in->height; y++)
for (z = 0 ; z < mri_in->depth; z++)
{
label = MRIgetVoxVal(mri_seg, x, y, z, 0) ;
TransformSourceVoxelToAtlas(transform, mri_in, x, y, z, &xatlas, &yatlas, &zatlas) ;
xt = nint(xatlas/tvoxel_size) ;
yt = nint(yatlas/tvoxel_size) ;
zt = nint(zatlas/tvoxel_size) ;
if (xt == Gx && yt == Gy && zt == Gz)
DiagBreak() ;
if ((IS_WMSA(label) == 0) &&
MRIgetVoxVal(mri_wmsa_possible,xt,yt, zt,0) == 0)
continue ;
if (NOT_TRAINING_LABEL(label))
continue ;
ntraining++ ;
if (IS_FUTURE_WMSA(label))
{
label = FUTURE_WMSA;
nfuture++ ;
}
else if (IS_WMSA(label))
{
label = WMSA ;
nwmsa++ ;
}
else
{
label = NOT_WMSA ;
nnot++ ;
}
// set label to one more than it will be for training so that 0 means this is not a training voxel
MRIsetVoxVal(mri_training_voxels, x, y, z, n, label+1) ;
}
}
correct = MRIcountNonzero(mri_training_voxels) ;
if (correct != ntraining)
DiagBreak() ;
printf("total training set size = %2.1fM\n", (float)ntraining/(1024.0f*1024.0f)) ;
printf("initial training set found with %dK FUTURE WMSA labels, %dK WMSA labels, and %dK non (ratio=%2.1f:%2.1f)\n",
nfuture/1000, nwmsa/1000, nnot/1000, (float)nnot/(float)nfuture, (float)nnot/(float)nwmsa) ;
MRIfree(&mri_wmsa_possible) ;
if (max_wm_wmsa_ratio*(nfuture+nwmsa) < nnot) // too many wm labels w.r.t. # of wmsas - remove some wm
{
int removed, total_to_remove = nnot - (max_wm_wmsa_ratio*(nfuture+nwmsa)) ;
double premove ;
premove = (double)total_to_remove / (double)nnot ;
printf("removing %dK WM indices to reduce training set imbalance (p < %f)\n", total_to_remove/1000, premove) ;
for (removed = n = 0 ; n < nsubjects ; n++)
for (x = 0 ; x < mri_in->width ; x++)
for (y = 0 ; y < mri_in->height; y++)
for (z = 0 ; z < mri_in->depth; z++)
{
label = MRIgetVoxVal(mri_training_voxels, x, y, z, n) ;
if (label == 1) // a WM voxel
{
if (randomNumber(0,1) < premove)
{
removed++ ;
MRIsetVoxVal(mri_training_voxels, x, y, z, n, 0) ; // remove it from training set
}
}
}
ntraining -= removed ;
printf("%d WM voxels removed, new training set size = %dM (ratio = %2.1f)\n",
removed, ntraining/(1024*1024), (double)(nnot-removed)/(double)(nwmsa+nfuture)) ;
}
correct = MRIcountNonzero(mri_training_voxels) ;
if (correct != ntraining)
DiagBreak() ;
// if (Gx >= 0)
{
int whalf = (parms->wsize-1)/2 ;
char buf[STRLEN] ;
rf->feature_names = (char **)calloc(rf->nfeatures, sizeof(char *)) ;
for (i = 0, x = -whalf ; x <= whalf ; x++)
for (y = -whalf ; y <= whalf ; y++)
for (z = -whalf ; z <= whalf ; z++)
for (n = 0 ; n < mri_in->nframes ; n++, i++)
{
switch (n)
{
default:
case 0: sprintf(buf, "T1(%d, %d, %d)", x, y, z) ; break ;
case 1: sprintf(buf, "T2(%d, %d, %d)", x, y, z) ;
break ;
case 2: sprintf(buf, "FLAIR(%d, %d, %d)", x, y, z) ;
if (x == 0 && y == 0 && z == 0)
Gdiag_no = i ;
break ;
}
rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ;
strcpy(rf->feature_names[i], buf) ;
}
printf("FLAIR(0,0,0) = %dth feature\n", Gdiag_no) ;
sprintf(buf, "CSF voxels in nbhd") ;
rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ;
strcpy(rf->feature_names[i], buf) ;
i++ ; sprintf(buf, "gm prior") ;
rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ;
strcpy(rf->feature_names[i], buf) ;
i++ ; sprintf(buf, "wm prior") ;
rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ;
strcpy(rf->feature_names[i], buf) ;
i++ ; sprintf(buf, "csf prior") ;
rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ;
strcpy(rf->feature_names[i], buf) ;
i++ ; sprintf(buf, "WMSA in nbhd") ;
rf->feature_names[i] = (char *)calloc(strlen(buf)+1, sizeof(char)) ;
strcpy(rf->feature_names[i], buf) ;
if (Gdiag & DIAG_WRITE)
{
printf("writing training voxels to tv.mgz\n") ;
MRIwrite(mri_training_voxels, "tv.mgz") ;
}
}
// now build training features and classes
training_classes = (int *)calloc(ntraining, sizeof(training_classes[0])) ;
if (training_classes == NULL)
ErrorExit(ERROR_NOFILE, "train_rforest: could not allocate %d-length training buffers",ntraining);
training_data = (double **)calloc(ntraining, sizeof(training_data[0])) ;
if (training_classes == NULL)
ErrorExit(ERROR_NOFILE, "train_rforest: could not allocate %d-length training buffers",ntraining);
for (i = n = 0 ; n < nsubjects ; n++)
{
mri_in = mri_inputs[n][0] ; mri_seg = mri_segs[n][0] ; transform = transforms[n][0] ;
for (x = 0 ; x < mri_in->width ; x++)
for (y = 0 ; y < mri_in->height; y++)
for (z = 0 ; z < mri_in->depth; z++)
{
if ((int)MRIgetVoxVal(mri_training_voxels, x, y, z, n) == 0)
continue ;
label = MRIgetVoxVal(mri_seg, x, y, z, 0) ;
TransformSourceVoxelToAtlas(transform, mri_in, x, y, z, &xatlas, &yatlas, &zatlas) ;
xt = nint(xatlas/tvoxel_size) ; yt = nint(yatlas/tvoxel_size) ; zt = nint(zatlas/tvoxel_size) ;
if (IS_FUTURE_WMSA(label))
tlabel = FUTURE_WMSA ;
else if (IS_WMSA(label))
tlabel = WMSA ;
else
tlabel= NOT_WMSA ;
training_classes[i] = tlabel ;
training_data[i] = (double *)calloc(nfeatures, sizeof(double)) ;
if (training_data[i] == NULL)
ErrorExit(ERROR_NOMEMORY, "train_rforest: could not allocate %d-len feature vector #%d",
nfeatures, i) ;
training_classes[i] = training_classes[i] ;
// extract_feature(mri_in, parms->wsize, x, y, z, training_data[i], xatlas, yatlas, zatlas) ;
extract_long_features(mri_in, mri_seg, transform, gca, parms->wsize, x, y, z, training_data[i]) ;
if (training_data[i][Gdiag_no] < 80 && training_classes[i] == 1)
DiagBreak() ;
i++ ;
}
MRIfree(&mri_in) ; MRIfree(&mri_seg) ; TransformFree(&transform) ;
}
if (i < ntraining)
{
printf("warning!!!! i (%d) < ntraining (%d)! Setting ntraining=i\n", i, ntraining) ;
ntraining = i ;
}
printf("training random forest with %dK FUTURE WMSA labels, %dK WMSA labels, and %dK non (ratio=%2.1f:%2.1f)\n",
nfuture/1000, nwmsa/1000, nnot/1000, (float)nnot/(float)nfuture, (float)nnot/(float)nwmsa) ;
RFtrain(rf, parms->feature_fraction, parms->training_fraction, training_classes, training_data, ntraining);
correct = RFcomputeOutOfBagCorrect(rf, training_classes, training_data,ntraining);
printf("out of bag accuracy: %d of %d = %2.2f%%\n", correct, ntraining,
100.0*correct/ntraining) ;
if (log_file_name)
{
struct flock fl;
int fd;
char line[MAX_LINE_LEN] ;
printf("writing results to train.log file %s\n", log_file_name) ;
fd = open(log_file_name, O_WRONLY|O_APPEND|O_CREAT, S_IRWXU|S_IRWXG);
if (fd < 0)
ErrorExit(ERROR_NOFILE, "%s: could not open test log file %s",
Progname, log_file_name);
fcntl(fd, F_SETLKW, &fl); /* F_GETLK, F_SETLK, F_SETLKW */
sprintf(line, "%f %d %d %f\n",
rf->training_fraction,
rf->max_depth,
rf->ntrees,
100.0*correct/ntraining) ;
write(fd, line, (strlen(line))*sizeof(char)) ;
fl.l_type = F_UNLCK; /* tell it to unlock the region */
fcntl(fd, F_SETLK, &fl); /* set the region to unlocked */
close(fd) ;
}
for (i = 0 ; i < ntraining ; i++) // allow for augmenting with other wmsa examples
free(training_data[i]) ;
free(training_data) ;
free(training_classes) ;
MRIfree(&mri_training_voxels) ;
return(rf) ;
}
void planarCNBGraph(Graph &G, int n, int m, int b)
{
G.clear();
if (b <= 0) b = 1;
if (n <= 0) n = 1;
if ((m <= 0) || (m > 3*n-6)) m = 3*n-6;
node cutv;
G.newNode();
for (int nB=1; nB<=b; nB++){
cutv = G.chooseNode();
// set number of nodes for the current created block
int actN = randomNumber(1, n);
node v1 = G.newNode();
if (actN <= 1){
G.newEdge(v1, cutv);
}
else
if (actN == 2){
node v2 = G.newNode();
G.newEdge(v1, v2);
int rnd = randomNumber(1, 2);
edge newE;
int rnd2 = randomNumber(1, 2);
if (rnd == 1){
newE = G.newEdge(v1, cutv);
}
else{
newE = G.newEdge(v2, cutv);
}
if (rnd2 == 1){
G.contract(newE);
}
}
else{
// set number of edges for the current created block
int actM;
if (m > 3*actN-6)
actM = randomNumber(1, 3*actN-6);
else
actM = randomNumber(1, m);
if (actM < actN)
actM = actN;
int ke = actN-3, kf = actM-actN;
Array<node> nodes(actN);
Array<edge> edges(actM);
Array<face> bigFaces(actM);
// we start with a triangle
node v2 = G.newNode(), v3 = G.newNode();
nodes[0] = v1;
nodes[1] = v2;
nodes[2] = v3;
edges[0] = G.newEdge(v1,v2);
edges[1] = G.newEdge(v2,v3);
edges[2] = G.newEdge(v3,v1);
int actInsertedNodes = 3;
CombinatorialEmbedding E(G);
FaceArray<int> posBigFaces(E);
int nBigFaces = 0, nEdges = 3;
while(ke+kf > 0) {
int p = randomNumber(1,ke+kf);
if (nBigFaces == 0 || p <= ke) {
int eNr = randomNumber(0,nEdges-1);
edge e = edges[eNr];
face f = E.rightFace(e->adjSource());
face fr = E.rightFace(e->adjTarget());
node u = e->source();
node v = e->target();
edges[nEdges++] = E.split(e);
if (e->source() != v && e->source() != u)
nodes[actInsertedNodes++] = e->source();
else
nodes[actInsertedNodes++] = e->target();
if (f->size() == 4) {
posBigFaces[f] = nBigFaces;
bigFaces[nBigFaces++] = f;
}
if (fr->size() == 4) {
posBigFaces[fr] = nBigFaces;
bigFaces[nBigFaces++] = fr;
}
ke--;
}
else {
int pos = randomNumber(0,nBigFaces-1);
face f = bigFaces[pos];
int df = f->size();
int i = randomNumber(0,df-1), j = randomNumber(2,df-2);
adjEntry adj1;
for (adj1 = f->firstAdj(); i > 0; adj1 = adj1->faceCycleSucc())
i--;
adjEntry adj2;
for (adj2 = adj1; j > 0; adj2 = adj2->faceCycleSucc())
j--;
edge e = E.splitFace(adj1,adj2);
edges[nEdges++] = e;
face f1 = E.rightFace(e->adjSource());
face f2 = E.rightFace(e->adjTarget());
bigFaces[pos] = f1;
posBigFaces[f1] = pos;
if (f2->size() >= 4) {
posBigFaces[f2] = nBigFaces;
bigFaces[nBigFaces++] = f2;
}
if (f1->size() == 3) {
bigFaces[pos] = bigFaces[--nBigFaces];
}
kf--;
}
}
// delete multi edges
SListPure<edge> allEdges;
EdgeArray<int> minIndex(G), maxIndex(G);
parallelFreeSortUndirected(G,allEdges,minIndex,maxIndex);
SListConstIterator<edge> it = allEdges.begin();
edge ePrev = *it, e;
for(it = ++it; it.valid(); ++it, ePrev = e) {
e = *it;
if (minIndex[ePrev] == minIndex[e] &&
maxIndex[ePrev] == maxIndex[e])
{
G.move(e,
e->adjTarget()->faceCycleSucc()->twin(), ogdf::before,
e->adjSource()->faceCycleSucc()->twin(), ogdf::before);
}
}
node cutv2 = nodes[randomNumber(0,actN-1)];
int rnd = randomNumber(1,2);
edge newE = G.newEdge(cutv2, cutv);
if (rnd == 1){
G.contract(newE);
}
}
}
};
void planarBiconnectedGraph(Graph &G, int n, int m, bool multiEdges)
{
if (n < 3) n = 3;
if (m < n) m = n;
if (m > 3*n-6) m = 3*n-6;
int ke = n-3, kf = m-n;
G.clear();
Array<edge> edges(m);
Array<face> bigFaces(m);
//random_source S;
// we start with a triangle
node v1 = G.newNode(), v2 = G.newNode(), v3 = G.newNode();
edges[0] = G.newEdge(v1,v2);
edges[1] = G.newEdge(v2,v3);
edges[2] = G.newEdge(v3,v1);
CombinatorialEmbedding E(G);
FaceArray<int> posBigFaces(E);
int nBigFaces = 0, nEdges = 3;
while(ke+kf > 0) {
int p = randomNumber(1,ke+kf);
if (nBigFaces == 0 || p <= ke) {
edge e = edges[randomNumber(0,nEdges-1)];
face f = E.rightFace(e->adjSource());
face fr = E.rightFace(e->adjTarget());
edges[nEdges++] = E.split(e);
if (f->size() == 4) {
posBigFaces[f] = nBigFaces;
bigFaces[nBigFaces++] = f;
}
if (fr->size() == 4) {
posBigFaces[fr] = nBigFaces;
bigFaces[nBigFaces++] = fr;
}
ke--;
} else {
int pos = randomNumber(0,nBigFaces-1);
face f = bigFaces[pos];
int df = f->size();
int i = randomNumber(0,df-1), j = randomNumber(2,df-2);
adjEntry adj1;
for (adj1 = f->firstAdj(); i > 0; adj1 = adj1->faceCycleSucc())
i--;
adjEntry adj2;
for (adj2 = adj1; j > 0; adj2 = adj2->faceCycleSucc())
j--;
edge e = E.splitFace(adj1,adj2);
edges[nEdges++] = e;
face f1 = E.rightFace(e->adjSource());
face f2 = E.rightFace(e->adjTarget());
bigFaces[pos] = f1;
posBigFaces[f1] = pos;
if (f2->size() >= 4) {
posBigFaces[f2] = nBigFaces;
bigFaces[nBigFaces++] = f2;
}
if (f1->size() == 3) {
bigFaces[pos] = bigFaces[--nBigFaces];
}
kf--;
}
}
if (multiEdges == false) {
SListPure<edge> allEdges;
EdgeArray<int> minIndex(G), maxIndex(G);
parallelFreeSortUndirected(G,allEdges,minIndex,maxIndex);
SListConstIterator<edge> it = allEdges.begin();
edge ePrev = *it, e;
for(it = ++it; it.valid(); ++it, ePrev = e) {
e = *it;
if (minIndex[ePrev] == minIndex[e] &&
maxIndex[ePrev] == maxIndex[e])
{
G.move(e,
e->adjTarget()->faceCycleSucc()->twin(), ogdf::before,
e->adjSource()->faceCycleSucc()->twin(), ogdf::before);
}
}
}
}
int Weapon::getDamage() {
return randomNumber(min_attack, max_attack);
}
int test(NumericT epsilon)
{
std::size_t N = 142; // should be larger than 128 in order to avoid false negatives due to blocking
viennacl::tools::uniform_random_numbers<NumericT> randomNumber;
//
// Vector setup and test:
//
std::vector<NumericT> std_x(N);
std::vector<NumericT> std_y(N);
std::vector<NumericT> std_z(N);
for (std::size_t i=0; i<std_x.size(); ++i)
std_x[i] = NumericT(i + 1);
for (std::size_t i=0; i<std_y.size(); ++i)
std_y[i] = NumericT(i*i + 1);
for (std::size_t i=0; i<std_z.size(); ++i)
std_z[i] = NumericT(2 * i + 1);
viennacl::vector<NumericT> vcl_x;
viennacl::vector<NumericT> vcl_y;
viennacl::vector<NumericT> vcl_z;
viennacl::copy(std_x, vcl_x);
viennacl::copy(std_y, vcl_y);
viennacl::copy(std_z, vcl_z);
// This shouldn't do anything bad:
vcl_x = vcl_x;
check(std_x, vcl_x, "x = x", epsilon);
// This should work, even though we are dealing with the same buffer:
std_x[0] = std_x[2]; std_x[1] = std_x[3];
viennacl::project(vcl_x, viennacl::range(0, 2)) = viennacl::project(vcl_x, viennacl::range(2, 4));
check(std_x, vcl_x, "x = x (range)", epsilon);
//
// Matrix-Vector
//
std::vector<std::vector<NumericT> > std_A(N, std::vector<NumericT>(N, NumericT(1)));
std::vector<std::vector<NumericT> > std_B(N, std::vector<NumericT>(N, NumericT(2)));
std::vector<std::vector<NumericT> > std_C(N, std::vector<NumericT>(N, NumericT(3)));
viennacl::matrix<NumericT> vcl_A;
viennacl::matrix<NumericT> vcl_B;
viennacl::matrix<NumericT> vcl_C;
viennacl::copy(std_A, vcl_A);
viennacl::copy(std_B, vcl_B);
viennacl::copy(std_C, vcl_C);
// This shouldn't do anything bad:
vcl_A = vcl_A;
check(std_A, vcl_A, "A = A", epsilon);
// This should work, even though we are dealing with the same buffer:
std_A[0][0] = std_A[0][2]; std_A[0][1] = std_A[0][3];
viennacl::project(vcl_A, viennacl::range(0, 1), viennacl::range(0, 2)) = viennacl::project(vcl_A, viennacl::range(0, 1), viennacl::range(2, 4));
check(std_A, vcl_A, "A = A (range)", epsilon);
// check x <- A * x;
for (std::size_t i = 0; i<std_y.size(); ++i)
{
NumericT val = 0;
for (std::size_t j = 0; j<std_x.size(); ++j)
val += std_A[i][j] * std_x[j];
std_y[i] = val;
}
vcl_x = viennacl::linalg::prod(vcl_A, vcl_x);
check(std_y, vcl_x, "x = A*x", epsilon);
typedef unsigned int KeyType;
std::vector< std::map<KeyType, NumericT> > std_Asparse(N);
for (std::size_t i=0; i<std_Asparse.size(); ++i)
{
if (i > 0)
std_Asparse[i][KeyType(i-1)] = randomNumber();
std_Asparse[i][KeyType(i)] = NumericT(1) + randomNumber();
if (i < std_Asparse.size() - 1)
std_Asparse[i][KeyType(i+1)] = randomNumber();
}
// Sparse
viennacl::compressed_matrix<NumericT> vcl_A_csr;
viennacl::coordinate_matrix<NumericT> vcl_A_coo;
viennacl::ell_matrix<NumericT> vcl_A_ell;
viennacl::sliced_ell_matrix<NumericT> vcl_A_sell;
viennacl::hyb_matrix<NumericT> vcl_A_hyb;
viennacl::copy(std_Asparse, vcl_A_csr);
viennacl::copy(std_Asparse, vcl_A_coo);
viennacl::copy(std_Asparse, vcl_A_ell);
viennacl::copy(std_Asparse, vcl_A_sell);
viennacl::copy(std_Asparse, vcl_A_hyb);
for (std::size_t i=0; i<std_Asparse.size(); ++i)
{
NumericT val = 0;
for (typename std::map<unsigned int, NumericT>::const_iterator it = std_Asparse[i].begin(); it != std_Asparse[i].end(); ++it)
val += it->second * std_x[it->first];
std_y[i] = val;
}
viennacl::copy(std_x, vcl_x);
vcl_x = viennacl::linalg::prod(vcl_A_csr, vcl_x);
check(std_y, vcl_x, "x = A*x (sparse, csr)", epsilon);
viennacl::copy(std_x, vcl_x);
vcl_x = viennacl::linalg::prod(vcl_A_coo, vcl_x);
check(std_y, vcl_x, "x = A*x (sparse, coo)", epsilon);
viennacl::copy(std_x, vcl_x);
vcl_x = viennacl::linalg::prod(vcl_A_ell, vcl_x);
check(std_y, vcl_x, "x = A*x (sparse, ell)", epsilon);
viennacl::copy(std_x, vcl_x);
vcl_x = viennacl::linalg::prod(vcl_A_sell, vcl_x);
check(std_y, vcl_x, "x = A*x (sparse, sell)", epsilon);
viennacl::copy(std_x, vcl_x);
vcl_x = viennacl::linalg::prod(vcl_A_hyb, vcl_x);
check(std_y, vcl_x, "x = A*x (sparse, hyb)", epsilon);
std::cout << std::endl;
//
// Matrix-Matrix (dense times dense):
//
test_gemm<op_assign>(epsilon, std_A, std_B, std_C, vcl_A, "A", vcl_B, "B", vcl_A, true);
test_gemm<op_assign>(epsilon, std_B, std_A, std_C, vcl_B, "B", vcl_A, "A", vcl_A, false);
test_gemm<op_assign>(epsilon, std_A, std_A, std_C, vcl_A, "A", vcl_A, "A", vcl_A, true);
std::cout << std::endl;
test_gemm<op_plus_assign>(epsilon, std_A, std_B, std_C, vcl_A, "A", vcl_B, "B", vcl_A, true);
test_gemm<op_plus_assign>(epsilon, std_B, std_A, std_C, vcl_B, "B", vcl_A, "A", vcl_A, false);
test_gemm<op_plus_assign>(epsilon, std_A, std_A, std_C, vcl_A, "A", vcl_A, "A", vcl_A, true);
std::cout << std::endl;
test_gemm<op_minus_assign>(epsilon, std_A, std_B, std_C, vcl_A, "A", vcl_B, "B", vcl_A, true);
test_gemm<op_minus_assign>(epsilon, std_B, std_A, std_C, vcl_B, "B", vcl_A, "A", vcl_A, false);
test_gemm<op_minus_assign>(epsilon, std_A, std_A, std_C, vcl_A, "A", vcl_A, "A", vcl_A, true);
std::cout << std::endl;
//
// Matrix-Matrix (sparse times dense)
//
// A = sparse * A
viennacl::copy(std_A, vcl_A);
for (std::size_t i = 0; i<std_A.size(); ++i)
for (std::size_t j = 0; j<std_A[i].size(); ++j)
{
NumericT tmp = 0;
for (std::size_t k = 0; k<std_A[i].size(); ++k)
tmp += std_Asparse[i][KeyType(k)] * std_A[k][j];
std_C[i][j] = tmp;
}
viennacl::copy(std_A, vcl_A);
vcl_A = viennacl::linalg::prod(vcl_A_csr, vcl_A);
check(std_C, vcl_A, "A = csr*A", epsilon);
viennacl::copy(std_A, vcl_A);
vcl_A = viennacl::linalg::prod(vcl_A_coo, vcl_A);
check(std_C, vcl_A, "A = coo*A", epsilon);
viennacl::copy(std_A, vcl_A);
vcl_A = viennacl::linalg::prod(vcl_A_ell, vcl_A);
check(std_C, vcl_A, "A = ell*A", epsilon);
viennacl::copy(std_A, vcl_A);
//vcl_A = viennacl::linalg::prod(vcl_A_sell, vcl_A);
//check(std_C, vcl_A, "A = sell*A", epsilon);
viennacl::copy(std_A, vcl_A);
vcl_A = viennacl::linalg::prod(vcl_A_hyb, vcl_A);
check(std_C, vcl_A, "A = hyb*A", epsilon);
// A = sparse * A^T
viennacl::copy(std_A, vcl_A);
for (std::size_t i = 0; i<std_A.size(); ++i)
for (std::size_t j = 0; j<std_A[i].size(); ++j)
{
NumericT tmp = 0;
for (std::size_t k = 0; k<std_A[i].size(); ++k)
tmp += std_Asparse[i][KeyType(k)] * std_A[j][k];
std_C[i][j] = tmp;
}
viennacl::copy(std_A, vcl_A);
vcl_A = viennacl::linalg::prod(vcl_A_csr, trans(vcl_A));
check(std_C, vcl_A, "A = csr*A^T", epsilon);
viennacl::copy(std_A, vcl_A);
vcl_A = viennacl::linalg::prod(vcl_A_coo, trans(vcl_A));
check(std_C, vcl_A, "A = coo*A^T", epsilon);
viennacl::copy(std_A, vcl_A);
vcl_A = viennacl::linalg::prod(vcl_A_ell, trans(vcl_A));
check(std_C, vcl_A, "A = ell*A^T", epsilon);
viennacl::copy(std_A, vcl_A);
//vcl_A = viennacl::linalg::prod(vcl_A_sell, trans(vcl_A));
//check(std_C, vcl_A, "A = sell*A^T", epsilon);
viennacl::copy(std_A, vcl_A);
vcl_A = viennacl::linalg::prod(vcl_A_hyb, trans(vcl_A));
check(std_C, vcl_A, "A = hyb*A^T", epsilon);
return EXIT_SUCCESS;
}
int main(int argc, char** argv) {
time_state state = START;
struct timespec now;
int fd;
char* sourceaddr;
int sourceport;
char buf[1024];
char output[1024];
int rc;
int signr;
struct sigevent sigev;
timer_t timer;
struct sched_param schedp;
sigset_t sigset;
uint64_t superframeStartTime;
uint64_t timeOffset;
uint64_t timeOffsetExtern;
int finished;
struct itimerspec tspec;
unsigned int frameCounter;
uint32_t beaconDelay;
/* Parse parameters */
if( argc != ARG_COUNT+1 ){
printf("Usage: clocksync <hostname> <portnummer> <adresse> <slotnummer>\n");
exit(1);
}
char hostname[128];
strncpy(hostname, argv[1], 127);
hostname[127] = '\0';
int port = atoi( argv[2] );
char * adresse = argv[3];
int slotnummer = atoi( argv[4] );
uint64_t timeOffsetMidOwnSlot = (20LL /*Beacon-Fenster*/ + 4 /*Sicherheitspause*/
+ (slotnummer-1)*4 /*Zeit bis zu eigenem slot*/ + (4/2) /*halbe slotlaenge*/);
printf("starting clocksync as: %s, at %s:%d with slotnummer %d\n",hostname,adresse,port,slotnummer);
//Initialisiere Socket.
//Trete der Multicast-Gruppe bei
//Aktiviere Signal SIGIO
fd = initSocket( adresse, port );
if( fd < 0 ){
printf("Failed initializing socket at: %s:%d.", adresse, port);
exit(1);
}
//Definiere Ereignis fuer den Timer
//Beim Ablaufen des Timers soll das Signal SIGALRM
//an die aktuelle Thread gesendet werden.
sigev.sigev_notify = SIGEV_THREAD_ID | SIGEV_SIGNAL;
sigev.sigev_signo = SIGALRM;
sigev.sigev_notify_thread_id = gettid();
//Erzeuge den Timer
timer_create(CLOCK, &sigev, &timer);
//Umschaltung auf Real-time Scheduler.
//Erfordert besondere Privilegien.
//Deshalb hier deaktiviert.
/*
memset(&schedp, 0, sizeof (schedp));
schedp.sched_priority = PRIO;
sched_setscheduler(0, POLICY, &schedp);
*/
//Lege fest, auf welche Signale beim
//Aufruf von sigwaitinfo gewartet werden soll.
sigemptyset(&sigset);
sigaddset(&sigset, SIGIO); //Socket hat Datagramme empfangen
sigaddset(&sigset, SIGALRM); //Timer ist abgelaufen
sigaddset(&sigset, SIGINT); //Cntrl-C wurde gedrueckt
sigprocmask(SIG_BLOCK, &sigset, NULL);
//Framecounter initialisieren
frameCounter = 0;
superframeStartTime = 0;
//Differenz zwischen der realen Zeit und der synchronisierten Anwendungszeit.
//Die synchronisierte Anwendungszeit ergibt sich aus der Beaconnummer.
//Sie wird gerechnet vom Startzeitpunkt des Superframes mit der Beaconnummer 0
timeOffset = 0;
timeOffsetExtern = 0;
/* wait 3 superframes for beacon from other units !TODO: check!*/
clock_gettime(CLOCK, &now);
tspec.it_interval.tv_sec = 0;
tspec.it_interval.tv_nsec = 0;
nsec2timespec( &tspec.it_value, TIME_START_WAIT_SUPERFRAMES * 100LL /*msec*/ *1000*1000 + timespec2nsec(&now));
timer_settime(timer, TIMER_ABSTIME, &tspec, NULL);
printf("Waiting for first beacon.\n");
//Merker fuer Programmende
finished = 0;
while( finished == 0 ){
//Lese empfangene Datagramme oder warte auf Signale
//Diese Abfrage ist ein wenig tricky, da das I/O-Signal (SIGIO)
//flankengesteuert arbeitet.
signr=0;
while( signr == 0 ){
//Pruefe, ob bereits Datagramme eingetroffen sind.
//Die muessen erst gelesen werden, da sonst fuer diese kein SIGIO-Signal ausgeloest wird.
//Signal wird erst gesendet beim Uebergang von Non-Ready nach Ready (Flankengesteuert!)
//Also muss Socket solange ausgelesen werden, bis es Non-Ready ist.
//Beachte: Socket wurde auf nonblocking umgeschaltet.
//Wenn keine Nachricht vorhanden ist, kehrt Aufruf sofort mit -1 zurueck. errno ist dann EAGAIN.
rc = recvMessage( fd, buf, sizeof(buf), &sourceaddr, &sourceport );
if( rc > 0 ){
//Ok, Datagram empfangen. Beende Schleife
signr = SIGIO;
break;
}
//Warte auf ein Signal.
//Die entsprechenden Signale sind oben konfiguriert worden.
siginfo_t info;
if (sigwaitinfo(&sigset, &info) < 0){
perror( "sigwait" );
exit(1);
}
if( info.si_signo == SIGALRM ){
//Timer ist abgelaufen
signr = SIGALRM;
break;
}else if( info.si_signo == SIGINT ){
//Cntrl-C wurde gedrueckt
signr = SIGINT;
break;
}
}
//So, gueltiges Ereignis empfangen.
//Nun geht es ans auswerten.
/* Get current time */
clock_gettime(CLOCK, &now);
#ifdef DEBUG
printf("received signal %d at state %d.\n",signr,state);
#endif // DEBUG
switch(state){
case START:
switch(signr){
case SIGALRM:
// no beacon received, I'm first to arrive
printf("no beacon arrived within %d superframes, so this must be the first unit.\n",TIME_START_WAIT_SUPERFRAMES);
// configure timer for next slottime
tspec.it_interval.tv_sec = 0;
tspec.it_interval.tv_nsec = 0;
superframeStartTime = timespec2nsec(&now);
nsec2timespec( &tspec.it_value, superframeStartTime + timeOffsetMidOwnSlot);
timer_settime(timer, TIMER_ABSTIME, &tspec, NULL);
timeOffset = timespec2nsec(&now); // init offset time
state = AWAIT_SLOT_TIME;
break; // case SIGALRM
case SIGIO:
if( buf[0] == 'B' ){
rc = decodeBeacon( buf, &frameCounter, &beaconDelay, NULL, 0);
if( rc < 0 ){
printf( "### Invalid Beacon: '%s'\n", buf );
} else {
printf("beacon arrived, this is not the first unit.\n");
//Berechne den Zeitpunkt, an dem der Superframe begann
superframeStartTime = timespec2nsec( &now ) - beaconDelay;
//Starte Zeitmessung mit dem ersten empfangenen Beacon
//Differenz zwischen der realen Zeit und der synchronisierten Anwendungszeit.
//Die synchronisierte Anwendungszeit ergibt sich aus der Beaconnummer.
//Sie wird gerechnet vom Startzeitpunkt des Superframes mit der Beaconnummer 0
timeOffset = superframeStartTime - frameCounter * 100LL /* msec */ * 1000 * 1000;
// configure timer for next slottime
tspec.it_interval.tv_sec = 0;
tspec.it_interval.tv_nsec = 0;
nsec2timespec( &tspec.it_value, superframeStartTime + timeOffsetMidOwnSlot);
timer_settime(timer, TIMER_ABSTIME, &tspec, NULL);
state = AWAIT_SLOT_TIME;
}
} else {
printf("### Received Message is no beacon: '%s'\n", buf );
}
break; // case SIGIO
case SIGINT:
printf("received SIGINT, shutting down.\n");
finished = 1;
break; // case SIGINT
} // switch signr
break; // case START
case AWAIT_BEACON:
switch(signr){
case SIGALRM:
// send beacon, since no beacon arrived before
frameCounter++;
// send own beacon
encodeBeacon(output, sizeof(output), frameCounter, beaconDelay, hostname);
sendMessage(fd, output, adresse, port);
superframeStartTime = (frameCounter * 100LL /* msec */*1000*1000) + timeOffset;
// configure timer for next slottime
tspec.it_interval.tv_sec = 0;
tspec.it_interval.tv_nsec = 0;
nsec2timespec( &tspec.it_value, superframeStartTime + timeOffsetMidOwnSlot);
timer_settime(timer, TIMER_ABSTIME, &tspec, NULL);
state = AWAIT_SLOT_TIME;
break; // case SIGALRM
case SIGIO:
if( buf[0] == 'B' ){
rc = decodeBeacon( buf, &frameCounter, &beaconDelay, NULL, 0);
if( rc < 0 ){
printf( "### Invalid Beacon: '%s'\n", buf );
} else {
printf("beacon arrived before sending own beacon.\n");
timeOffsetExtern = timespec2nsec(&now) - (frameCounter * 100LL /* msec */*1000*1000) - beaconDelay;
// check, if other starttime is before own calculated offset and adjust offset if needed
if(timeOffsetExtern < timeOffset){
timeOffset = timeOffsetExtern;
}
//Berechne den Zeitpunkt, an dem der Superframe begann
superframeStartTime = (frameCounter * 100LL /* msec */*1000*1000) + timeOffset;
// configure timer for next slottime
tspec.it_interval.tv_sec = 0;
tspec.it_interval.tv_nsec = 0;
nsec2timespec( &tspec.it_value, superframeStartTime + timeOffsetMidOwnSlot);
timer_settime(timer, TIMER_ABSTIME, &tspec, NULL);
state = AWAIT_SLOT_TIME;
}
} else {
#ifdef DEBUG
printf("### Received Message is no beacon: '%s'\n",buf);
#endif // DEBUG
}
break; // case SIGIO
case SIGINT:
printf("received SIGINT, shutting down.\n");
finished = 1;
break; // case SIGINT
} // switch signr
break; // case AWAIT_BEACON
case AWAIT_SLOT_TIME:
switch(signr){
case SIGALRM:
// send own datagram
encodeSlotMessage(output, sizeof(output), slotnummer, hostname);
sendMessage(fd, output, adresse, port);
// calculate own random delay for next beacon
beaconDelay = randomNumber(20 /*msec*/ *1000*1000);
// configure timer for next beacon send time
tspec.it_interval.tv_sec = 0;
tspec.it_interval.tv_nsec = 0;
nsec2timespec( &tspec.it_value, superframeStartTime + 100LL /*msec*/ *1000*1000 + beaconDelay);
timer_settime(timer, TIMER_ABSTIME, &tspec, NULL);
state = AWAIT_BEACON;
break; // case SIGALRM
case SIGIO:
//TODO: maybe error message?
break; // case SIGIO
case SIGINT:
printf("received SIGINT, shutting down.\n");
finished = 1;
break; // case SIGINT
} // switch signr
break; // case AWAIT_SLOT_TIME
} // switch state
} // while finished == 0
////////////////////////////////////////////////////
//und aufraeumen
timer_delete(timer);
/* switch to normal */
schedp.sched_priority = 0;
sched_setscheduler(0, SCHED_OTHER, &schedp);
return 0;
}
void randomTriconnectedGraph(Graph &G, int n, double p1, double p2)
{
if(n < 4) n = 4;
// start with K_4
completeGraph(G,4);
// nodes[0],...,nodes[i-1] is array of all nodes
Array<node> nodes(n);
node v;
int i = 0;
forall_nodes(v,G)
nodes[i++] = v;
// Will be used below as array of neighbors of v
Array<edge> neighbors(n);
// used to mark neighbors
// 0 = not marked
// 1 = marked left
// 2 = marked right
// 3 = marked both
Array<int> mark(0,n-1,0);
for(; i < n; ++i)
{
// pick a random node
v = nodes[randomNumber(0,i-1)];
// create a new node w such that v is split into v and w
node w = nodes[i] = G.newNode();
// build array of all neighbors
int d = v->degree();
int j = 0;
adjEntry adj;
forall_adj(adj,v)
neighbors[j++] = adj->theEdge();
// mark two distinct neighbors for left
for(j = 2; j > 0; ) {
int r = randomNumber(0,d-1);
if((mark[r] & 1) == 0) {
mark[r] |= 1; --j;
}
}
// mark two distinct neighbors for right
for(j = 2; j > 0; ) {
int r = randomNumber(0,d-1);
if((mark[r] & 2) == 0) {
mark[r] |= 2; --j;
}
}
for(j = 0; j < d; ++j) {
int m = mark[j];
mark[j] = 0;
// decide to with which node each neighbor is connected
// (possible: v, w, or both)
double x = randomDouble(0.0,1.0);
switch(m)
{
case 0:
if(x < p1)
m = 1;
else if(x < p1+p2)
m = 2;
else
m = 3;
break;
case 1:
case 2:
if(x >= p1+p2) m = 3;
break;
}
// move edge or create new one if necessary
edge e = neighbors[j];
switch(m)
{
case 2:
if(v == e->source())
G.moveSource(e,w);
else
G.moveTarget(e,w);
break;
case 3:
G.newEdge(w,e->opposite(v));
break;
}
}
G.newEdge(v,w);
}
}
void populateArray(int *list, int size){
int i = 0;
for(i = 0; i < size; i++){
list[i] = randomNumber();
}
}
void planarTriconnectedGraph(Graph &G, int n, int m)
{
if (n < 4) n = 4;
if(n % 2) ++n; // need an even number
// start with K_4
completeGraph(G,4);
planarEmbedPlanarGraph(G);
// nodes[0],...,nodes[i-1] is array of all nodes
Array<node> nodes(n);
node v;
int i = 0;
forall_nodes(v,G)
nodes[i++] = v;
// create planar triconnected 3-graph
for(; i < n; )
{
// pick a random node
v = nodes[randomNumber(0,i-1)];
adjEntry adj2 = v->firstAdj();
int r = randomNumber(0,2);
switch(r) {
case 2: adj2 = adj2->succ(); // fall through to next case
case 1: adj2 = adj2->succ();
}
adjEntry adj1 = adj2->cyclicSucc();
nodes[i++] = G.splitNode(adj1,adj2);
r = randomNumber(0,1);
if(r == 0) {
adjEntry adj = adj1->twin();
G.newEdge(adj2,adj);
nodes[i++] = G.splitNode(adj,adj->cyclicSucc()->cyclicSucc());
} else {
adjEntry adj = adj1->cyclicSucc()->twin();
G.newEdge(adj2,adj,ogdf::before);
nodes[i++] = G.splitNode(adj->cyclicPred(),adj->cyclicSucc());
}
}
nodes.init();
Array<edge> edges(m);
CombinatorialEmbedding E(G);
Array<face> faces(2*n);
i = 0;
face f;
forall_faces(f,E) {
if(f->size() >= 4)
faces[i++] = f;
}
while(G.numberOfEdges() < m && i > 0)
{
int r = randomNumber(0,i-1);
f = faces[r];
faces[r] = faces[--i];
int p = randomNumber(0,f->size()-1);
int j = 0;
adjEntry adj, adj2;
for(adj = f->firstAdj(); j < p; adj = adj->faceCycleSucc(), ++j) ;
p = randomNumber(2, f->size()-2);
for(j = 0, adj2 = adj; j < p; adj2 = adj2->faceCycleSucc(), ++j) ;
edge e = E.splitFace(adj,adj2);
f = E.rightFace(e->adjSource());
if(f->size() >= 4) faces[i++] = f;
f = E.rightFace(e->adjTarget());
if(f->size() >= 4) faces[i++] = f;
}
}
int main(int argc, char * argv[]) {
int test_trials = 10000;
if (argc > 1) {
test_trials = atoi(argv[1]);
if (test_trials < 1) {
printf("Usage: cardtest1 <trials>\r\n");
exit(1);
}
}
srand(time(NULL));
//new gameState
struct gameState * gs = malloc(sizeof(struct gameState));
struct gameState * stateCopy = malloc(sizeof(struct gameState));
int trial;
int returnValue;
int numberOfErrors = 0;
int playerNum;
int emptyHand;
int emptyDiscard;
int emptyDeck;
int emptyThree; //not enough cards?
int handPos;
int drawCards;
printf("Card Test 1\r\n");
printf("Conducting %d random trials.\r\n", test_trials);
for (trial = 0; trial < test_trials; trial++) {
printf("TRIAL %d\r\n", trial);
fuzzState(gs);
//semi-randomize inputs (within reason)
playerNum = randomNumber(2, MAX_PLAYERS) - 2;
emptyDeck = percentChanceIsOne(5);
emptyDiscard = percentChanceIsOne(5);
emptyHand = percentChanceIsOne(5);
emptyThree = percentChanceIsOne(1);
if (emptyDeck == 1 || emptyThree == 1) {
gs->deckCount[playerNum] = 0;
} else {
gs->deckCount[playerNum] = randomNumber(1, 300);
}
if (emptyHand == 1 || emptyThree == 1) {
gs->handCount[playerNum] = 1; //leave room for Smithy card
} else {
gs->handCount[playerNum] = randomNumber(2, 300);
}
if (emptyDiscard == 1 || emptyThree == 1) {
gs->discardCount[playerNum] = 0;
} else {
gs->discardCount[playerNum] = randomNumber(1, 300);
}
gs->playedCardCount = randomNumber(0,gs->handCount[playerNum]);
/*gs->deckCount[playerNum] = randomNumber(5, 300);
gs->discardCount[playerNum] = randomNumber(5, 300);
gs->handCount[playerNum] = randomNumber(5, 300);
*/
//set smithy card
handPos = randomNumber(0, gs->handCount[playerNum]-1);
gs->hand[playerNum][handPos] = smithy;
//create copy for comparison later
memcpy(stateCopy, gs, sizeof(struct gameState));
//RUN FUNCTION
returnValue = playSmithy(handPos, playerNum, gs);
//Check state
if (stateCopy->deckCount[playerNum] < 3) {
if (gs->discardCount[playerNum] != 1) {
printf("discardCount is not as expected. Expected: 1, Actual: %d\r\n", gs->discardCount[playerNum]);
numberOfErrors++;
}
} else {
if (gs->discardCount[playerNum] != stateCopy->discardCount[playerNum] + 1) {
printf("discardCount is not as expected. Expected: %d, Actual: %d\r\n",stateCopy->discardCount[playerNum] + 1, gs->discardCount[playerNum]);
numberOfErrors++;
}
}
//check top of discard for smithy
if (gs->discard[playerNum][ gs->discardCount[playerNum] - 1 ] != smithy){
printf("top of discard mismatch. Expected: %d, Actual %d\r\n", smithy, gs->discard[playerNum][ gs->discardCount[playerNum] - 1 ]);
numberOfErrors++;
}
if (stateCopy->discardCount[playerNum] + stateCopy->deckCount[playerNum] >= 3) {
drawCards = 3;
} else {
drawCards = stateCopy->discardCount[playerNum] + stateCopy->deckCount[playerNum];
}
//drawCards should be drawCards less pluss smithy
if (gs->discardCount[playerNum] + gs->deckCount[playerNum] - drawCards + 1 != stateCopy->discardCount[playerNum] + stateCopy->deckCount[playerNum]) {
printf("deck + discard count is not as expected. Expected: %d, Actual: %d\r\n",stateCopy->discardCount[playerNum] + stateCopy->deckCount[playerNum] - drawCards + 1, gs->discardCount[playerNum] + gs->deckCount[playerNum]);
numberOfErrors++;
}
//Hand Should have drawCards extra cards minus smithy
if (gs->handCount[playerNum] != stateCopy->handCount[playerNum] + drawCards - 1) {
printf("handCount is not as expected. Expected: %d, Actual: %d\r\n",stateCopy->handCount[playerNum] + drawCards - 1, gs->handCount[playerNum]);
numberOfErrors++;
}
}
printf("Card Test 1 Complete\r\n");
printf("Number of errors found: %d\r\n", numberOfErrors);
free(gs);
free(stateCopy);
return 0;
}
//do nothing for now.
void *sendPacket()
{
printf("Sender started.\n\n");
int i;
int numbytes;
int curr_pos = 0;
//simulating corruption
int rand;
while(1){
//flag set by receiver to resend packets currently in window.
if(resend){
resendPackets(left, right);
}
//sends anytime something gets pushed onto our buffer
if((num_in_buffer - sent_unacked) > 0){
/*
* rand < 10, no send.
* rand >= 10, gen another rand. If < 5, set corrupt to 1. Else, 0.
*/
rand = randomNumber(100);
printf("RAND # %d\n", rand);
/*if(rand < 10)
printf("Do not send packet\n");
else{
rand = randomNumber(100);
if(rand < 5) printf("Setting corrupt bit\n");
else printf("normal packet\n");
}*/
sleep(1); //delay
if(buffer[curr_pos]->seq < 0){ //Wait for done packet. if we hit done, halt and wait.
if(outstanding == 0){ //dont send until we have none outstanding.
//finish this.
if(rand > 10){
rand = randomNumber(100);
if(rand < 5) {
printf("Setting corrupt bit\n");
buffer[curr_pos]->corrupt = 1;
} else {
printf("Normal packet\n");
buffer[curr_pos]->corrupt = 0;
}
if ((numbytes = sendto(sockfd, (void *) buffer[curr_pos], sizeof(struct packet), 0,
p->ai_addr, p->ai_addrlen)) == -1) {
perror("talker: sendto");
exit(1);
}
printf("Just sent our death pill with left = %d curr post = %d. Peace.\n\n", left, curr_pos);
exit(1); //kill program
}else{
printf("Skipping packet\n");
}
}
}else{
if(rand > 10){
rand = randomNumber(100);
if(rand < 5){
printf("Setting corrupt bit\n");
buffer[curr_pos]->corrupt = 1;
} else {
printf("Normal packet\n");
buffer[curr_pos]->corrupt = 0;
}
if ((numbytes = sendto(sockfd, (void *) buffer[curr_pos], sizeof(struct packet), 0,
p->ai_addr, p->ai_addrlen)) == -1) {
perror("talker: sendto");
exit(1);
}
} else{
printf("Skipping packet\n");
}
printf("SENT: %s with seq # %d\n\n", buffer[curr_pos]->data, buffer[curr_pos]->seq);
just_sent = TRUE; //this flag will allow receiver to start timer again.
curr_pos = ((curr_pos + 1) % BUFF_SIZE);
sent_unacked++; //increment sent but unacked
outstanding++;
//printf("Number unacked %d\n", outstanding);
}
}
}
}
int main(int argc, char *argv[])
{
/* { fix start } */
ltc_mp = ltm_desc;
/* { fix end } */
int sockfd = 0;
struct sockaddr_in serv_addr;
if(argc != 2)
{
printf("\n Usage: %s <ip of server> \n",argv[0]);
return 1;
}
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Error : Could not create socket \n");
return 1;
}
memset(&serv_addr, '0', sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(5002);
if(inet_pton(AF_INET, argv[1], &serv_addr.sin_addr)<=0)
{
printf("\n inet_pton error occured\n");
return 1;
}
if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
printf("\n Error : Connect Failed \n");
return 1;
}
initEncrypt();
ecc_key encryptKey;
loadKey(&encryptKey, "bpublic.key");
ecc_key decryptKey;
loadKey(&decryptKey, "aprivate.key");
/* { userString start } */
printf("Enter message to send\n");
unsigned char message[256];
fgets((char*)message,256,stdin);
/* { userString end } */
/* { sendNonceA start } */
int nonceA = randomNumber();
printf("nonceA = %i\n",nonceA);
printf("Encrypting nonceA with bpub\n");
unsigned char nonceA_enc[2048];
unsigned long outLength = 2048;
ecc_encrypt((unsigned char*)&nonceA, sizeof(int), nonceA_enc, &outLength,&encryptKey);
printf("Sending nonceA\n");
write(sockfd, nonceA_enc, outLength);
/* { sendNonceA end } */
/* { resiveSessionKey start } */
unsigned char recvBuff[1024];
unsigned long msgLength;
msgLength = recv(sockfd, recvBuff, sizeof(recvBuff),0);
struct SessionKey sKey;
unsigned long inLength = sizeof(struct SessionKey);
ecc_decrypt(recvBuff,msgLength,(unsigned char*)&sKey,&inLength,&decryptKey);
printf("Received sKey, nonceA = %i, key = %i\n", sKey.nonceA, sKey.key);
/* { resiveSessionKey end } */
/* { resendKey start } */
my_aes_setup(sKey.key);
sKey.nonceA ++;
printf("Sending nonceA = %i encrypted with AES\n", sKey.nonceA);
outLength = 2048;
aes_encrypt((unsigned char*)&sKey.nonceA,sizeof(int),nonceA_enc, &outLength);
write(sockfd, nonceA_enc, outLength);
/* { resendKey end } */
/* { sendMessage start } */
printf("Sending message encrypted with AES\n");
printf("%s", message);
outLength = 2048;
unsigned char message_enc[2048];
aes_encrypt(message, strlen((char*)message), message_enc, &outLength);
write(sockfd, message_enc, outLength);
/* { sendMessage end } */
return -1;
}
void randomHierarchy(Graph &G,
int numberOfNodes,int numberOfEdges,
bool planar,bool singleSource,bool longEdges)
{
G.clear();
node *nnr = new node[3*numberOfNodes];
int *vrt = new int[3*numberOfNodes];
int *fst = new int[numberOfNodes+1];
List<bEdge> startEdges;
bEdge actEdge, nextEdge, toDelete;
node v;
int act, next, n1, n2, idc=0;
double x1, x2, r;
bool connected;
/** Place nodes **/
for(int i = 0; i < numberOfNodes; i++)
G.newNode();
int numberOfLayers=0, totNumber=0, realCount=0;
fst[0] = 0;
forall_nodes(v,G) {
if(longEdges&&numberOfLayers) vrt[totNumber++] = 1;
nnr[totNumber] = v;
vrt[totNumber++] = 0;
realCount++;
r = double(randomNumber(0,1000)) / 1000.0;
if((totNumber == 1 && singleSource) || realCount == numberOfNodes || r*r*numberOfNodes < 1)
{
if(longEdges && numberOfLayers)
vrt[totNumber++] = 1;
fst[++numberOfLayers] = totNumber;
}
}
/** Determine allowed neighbours **/
int *leftN = new int[totNumber];
int *rightN = new int[totNumber];
for(int l = 1; l < numberOfLayers; l++)
{
if(planar) {
n1 = fst[l-1];
n2 = fst[l];
leftN[n2] = n1;
while(n1 < fst[l] && n2 < fst[l+1]) {
r = double(randomNumber(0,1000)) / 1000.0;
if(n1 != fst[l]-1 &&
(n2 == fst[l+1]-1 ||
r < (double)(fst[l]-fst[l-1])/(double)(fst[l+1]-fst[l-1])))
n1++;
else {
rightN[n2] = n1;
if(++n2 < fst[l+1])
leftN[n2] = n1;
}
}
}
else
for(n2 = fst[l]; n2 < fst[l+1]; n2++) {
leftN [n2] = fst[l-1];
rightN[n2] = fst[l]-1;
}
}
/** Insert edges **/
SList<bEdge> *edgeIn = new SList<bEdge>[totNumber];
SList<bEdge> *edgeOut = new SList<bEdge>[totNumber];
if(numberOfLayers) {
x1 = numberOfEdges;
x2 = 0;
for(n2 = fst[1]; n2 < totNumber; n2++)
if(!vrt[n2])
x2 += rightN[n2] - leftN[n2]+1;
for(n2 = fst[1]; n2 < totNumber; n2++)
if(!vrt[n2]) {
connected = !singleSource;
for(n1 = leftN[n2]; n1 <= rightN[n2] || !connected; n1++) {
r = double(randomNumber(0,1000)) / 1000.0;
if(r < x1/x2 || n1 > rightN[n2]) {
next = (n1 <= rightN[n2] ? n1 : randomNumber(leftN[n2],rightN[n2]));
act = n2;
nextEdge = OGDF_NEW BEdge(next,act,idc++);
while(vrt[next]) {
act = next;
next = randomNumber(leftN[act],rightN[act]);
edgeOut[act].pushBack(nextEdge);
nextEdge = OGDF_NEW BEdge(next,act,idc++);
edgeIn[act].pushBack(nextEdge);
}
startEdges.pushBack(nextEdge);
connected = 1;
x1 -= 1;
}
if(n1<=rightN[n2])
x2-=1;
}
}
}
delete[] leftN;
delete[] rightN;
if(planar)
for(act = 0; act < totNumber; act++) {
CmpTail cmpTail;
edgeIn[act].quicksort(cmpTail);
CmpHead cmpHead;
edgeOut[act].quicksort(cmpHead);
}
for(act = 0; act < totNumber; act++) {
SListIterator<bEdge> it;
for(it = edgeIn[act].begin(); it.valid(); ++it) {
nextEdge = *it;
nextEdge->next = edgeOut[act].popFrontRet();
}
}
delete[] edgeOut;
ListIterator<bEdge> it;
for(it = startEdges.begin(); it.valid(); ++it) {
actEdge = *it;
nextEdge = actEdge;
while(vrt[nextEdge->head])
nextEdge = nextEdge->next;
G.newEdge(nnr[actEdge->tail], nnr[nextEdge->head]);
}
/** Clean up **/
for(it = startEdges.begin(); it.valid(); ++it) {
nextEdge = *it;
toDelete = nextEdge;
while(vrt[nextEdge->head]) {
nextEdge = nextEdge->next;
delete toDelete;
toDelete = nextEdge;
}
delete toDelete;
}
delete[] edgeIn;
delete[] fst;
delete[] vrt;
delete[] nnr;
}
int main(int argc, char * argv[])
{
char const * fn = NULL;
int64_t fs = -1;
static int64_t const maxrelfs = 512*1024*1024;
static unsigned int numthreads = 32;
static int const runs = 128;
int t = 0;
int allok = 1;
if ( !(1<argc) )
{
fprintf(stderr,"usage: %s <filename>\n",argv[0]);
return EXIT_FAILURE;
}
fn = argv[1];
srandom(time(NULL));
if ( (fs=getFileSize(fn)) < 0 )
{
int const error = errno;
fprintf(stderr,"Failed to obtain file size: %s\n", strerror(error));
return EXIT_FAILURE;
}
fprintf(stderr,"Size of file is %" PRIu64 "\n", (uint64_t)fs);
if ( fs > maxrelfs )
fs = maxrelfs;
for ( t = 0; allok && (t < runs); ++t )
{
uint64_t low = randomNumber(8) % (fs+1);
uint64_t high = randomNumber(8) % (fs+1);
int rc = -1;
char * mem = 0;
uint64_t memsize = 0;
char * tmem = 0;
FILE * file = NULL;
int ok = 1;
uint64_t i;
if ( low > high )
{
uint64_t tlow = low;
low = high;
high = tlow;
}
rc = liblustreparallelread_readfilepart(fn,low,high,numthreads,&mem,&memsize);
if ( rc < 0 )
{
int const error = errno;
fprintf(stderr, "liblustreparallelread_readfilepart failed: %s\n", strerror(error));
return EXIT_FAILURE;
}
tmem = (char *)malloc(high-low);
if ( ! tmem )
{
int const error = ENOMEM;
free(mem);
fprintf(stderr, "verification failed: %s\n", strerror(error));
return EXIT_FAILURE;
}
if ( ! (file=fopen(fn,"rb")) )
{
int const error = errno;
free(mem);
free(tmem);
fprintf(stderr, "verification failed: %s\n", strerror(error));
return EXIT_FAILURE;
}
if ( fseek(file,low,SEEK_SET) == -1 )
{
int const error = errno;
fclose(file);
free(mem);
free(tmem);
fprintf(stderr, "verification failed: %s\n", strerror(error));
return EXIT_FAILURE;
}
if ( fread(tmem,high-low,1,file) != 1 )
{
int const error = errno;
fclose(file);
free(mem);
free(tmem);
fprintf(stderr, "verification failed: %s\n", strerror(error));
return EXIT_FAILURE;
}
ok = 1;
for ( i = 0; ok && i < (high-low); ++i )
ok = ok && (mem[i] == tmem[i]);
fprintf(stderr,"low %" PRIu64 " high %" PRIu64 " dif %" PRIu64 " %s\n", low, high, (high-low)/(1024*1024), (ok?"ok":"failed"));
allok = allok && ok;
fclose(file);
free(tmem);
free(mem);
}
if ( allok )
{
fprintf(stderr,"ok\n");
return EXIT_SUCCESS;
}
else
{
fprintf(stderr,"failed\n");
return EXIT_FAILURE;
}
}
ValueCell::ValueCell() : CellBase(), my_value(randomNumber(MINVAL, MAXVAL)) { }
void Rts2SchedBag::doNSGAIIStep ()
{
// we hold pointers to both parent and child population used/produced by previous step
calculateNSGARanks ();
// pick n members as parents of new population
Rts2Schedule *new_pop[popSize];
unsigned int n = 0;
unsigned int f;
unsigned int i;
for (f = 0; f < NSGAfronts.size (); f++)
{
calculateNSGACrowdingDistance (f);
if (NSGAfronts[f].size () < (popSize - n))
{
// copy schedules..
std::vector <Rts2Schedule *>::iterator iter;
for (iter = NSGAfronts[f].begin (); iter != NSGAfronts[f].end(); iter++, n++)
new_pop[n] = (*iter);
NSGAfronts[f].clear ();
}
else
{
// sort based on crowding distance
std::sort (NSGAfronts[f].begin (), NSGAfronts[f].end (), crowdingComp ());
// copy missing entries..
std::vector <Rts2Schedule *>::iterator iter = NSGAfronts[f].begin ();
for (i = 0; n < popSize; i++, n++)
{
new_pop[n] = (*iter);
iter = NSGAfronts[f].erase (iter);
}
// delete rest of NSGAfronts..
while (iter != NSGAfronts[f].end ())
{
delete (*iter);
iter = NSGAfronts[f].erase (iter);
}
while (f < NSGAfronts.size ())
{
iter = NSGAfronts[f].begin ();
while (iter != NSGAfronts[f].end ())
{
delete (*iter);
iter = NSGAfronts[f].erase (iter);
}
f++;
}
}
}
// erase current population - its pointer are either in new_pop or deleted..
clear ();
reserve (popSize * 2);
// put to bag remaining schedules..
for (i = 0; i < popSize; i++)
push_back (new_pop[i]);
// now new_pop holds members of new population ready for binary tournament..
// we need to calculate indices of population for tournament
unsigned int a1[popSize], a2[popSize];
for (i = 0; i < popSize; i++)
a1[i] = a2[i] = i;
for (i = 0; i < popSize; i++)
{
unsigned int rand = randomNumber (i, popSize - 1);
unsigned int temp = a1[rand];
a1[rand] = a1[i];
a1[i] = temp;
rand = randomNumber (i, popSize - 1);
temp = a2[rand];
a2[rand] = a2[i];
a2[i] = temp;
}
// do tournament
for (i = 0; i < popSize; i+=4)
{
Rts2Schedule *parent1 = tournamentNSGA (new_pop[a1[i]], new_pop[a1[i+1]]);
Rts2Schedule *parent2 = tournamentNSGA (new_pop[a1[i+2]], new_pop[a1[i+3]]);
cross (parent1, parent2);
parent1 = tournamentNSGA (new_pop[a2[i]], new_pop[a2[i+1]]);
parent2 = tournamentNSGA (new_pop[a2[i+2]], new_pop[a2[i+3]]);
cross (parent1, parent2);
}
for (int m = 0; m < mutationNum; m++)
{
mutate ((*this)[randomNumber (popSize, popSize * 2 - 1)]);
}
}
GoldCell::GoldCell() : ValueCell(), my_bonus(randomNumber(MINVALB, MAXVALB)) { }
int Random::getRandomNumber(int min, int max)
{
std::uniform_int_distribution<int> randomNumber{ min, max };
return randomNumber(dre);
}
