int main(int argc, char* argv[])
{
installSignalHandlers();
printLibraryVersions();
/** Setup D-BUS information */
QCoreApplication::setOrganizationName("QlixIsOSS");
QCoreApplication::setOrganizationDomain("Qlix.berlios.de");
QCoreApplication::setApplicationName("Qlix");
/** Setup QSettings */
QSettings settings;
QString ret = settings.value("DefaultDevice").toString();
/** Setup QApplication */
QApplication app(argc, argv);
app.setStyle("Plastique");
/** Grab AutoFix options */
CommandLineOptions opts = ParseCommandLineOptions(argc, argv);
_subSystem.SetAutoFixOptions(opts);
if (opts.AutoFixPlaylists)
cout << "Working" << endl;
//app.setStyleSheet("QTreeView::branch:!adjoins-item{ border-color: none;}"); works
//app.setStyleSheet("QTreeView::branch:!adjoins-item{ background: none}");
//app.setStyleSheet("QTreeView::branch:!adjoins-item:!has-children{ foreground: red}");
//app.setStyleSheet("QTreeView::branch:adjoins-item:has-children{ background: cyan}");
QlixMainWindow qmw(&_subSystem);
qmw.show();
Q_INIT_RESOURCE(Qlix);
app.exec();
return 0;
}
/*
the main program
*/
int main( int argc, char *argv[])
{
Credits( stdout);
argv++;
argc--;
/* read command line options */
ParseCommandLineOptions( argc, argv);
/* load the Wad files */
OpenMainWad( MainWad);
if (PatchWads)
while (PatchWads[ 0])
{
OpenPatchWad( PatchWads[ 0]);
PatchWads++;
}
/* sanity check */
CloseUnusedWadFiles();
/* all systems go! */
MainLoop();
/* that's all, folks! */
CloseWadFiles();
exit( 0);
}
int main(int argc, char* argv[])
{
po::variables_map para = ParseCommandLineOptions(argc, argv);
////////////////////////////////////////////////////////////////////////////////
//{{{ MPI Preparation
int worker_num(0), my_rank(0);
int mpi_status = MPI_Init(&argc, &argv);
assert (mpi_status == MPI_SUCCESS);
MPI_Comm_size(MPI_COMM_WORLD, &worker_num);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
//}}}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//{{{ LOGGING
string log_file = LOG_PATH + para["logfile"].as<string>();
_START_EASYLOGGINGPP(argc, argv);
easyloggingpp::Configurations confFromFile(log_file.c_str());
easyloggingpp::Loggers::reconfigureAllLoggers(confFromFile);
//}}}
////////////////////////////////////////////////////////////////////////////////
LOG(INFO) << "my_rank = " << my_rank << " vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv Program begins vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv";
EnsembleCCE sol(my_rank, worker_num, para);
// Step 1: make a defect center
NVCenter nv = create_defect_center(para);
sol.set_defect_center(&nv);
// Step 2: make bath spins
cSpinSourceUniformRandom spinUR = create_spin_source(para);
sol.set_bath_spin(&spinUR);
// Step 3: make clusters
cSpinCollection bath_spins = sol.getSpinCollecion();
cDepthFirstPathTracing dfpt = create_spin_cluster_algrithm(para, bath_spins);
sol.set_bath_cluster(&dfpt);
// Step 4: run_each_cluster
sol.run_each_clusters();
// Step 5: post_treatment
sol.post_treatment();
LOG(INFO) << "my_rank = " << my_rank << " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Program ends ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^";
////////////////////////////////////////////////////////////////////////////////
//{{{ MPI Finializing
mpi_status = MPI_Finalize();
assert (mpi_status == MPI_SUCCESS);
//}}}
////////////////////////////////////////////////////////////////////////////////
}
/*******************************************************************************
* Main function
******************************************************************************/
int
main( int argc, char *argv[] )
{
int status;
/* Initialization */
ParseCommandLineOptions( argc, argv );
/* Reading configuration options from configuration file. */
ConfigurationFileInit();
/* For catching the termination signal SIGCHLD when the external mail client
program is terminated, thus permitting removing zombi processes... */
(void) signal( SIGCHLD, CatchChildTerminationSignal );
/* Initialize callback function pointers. */
ProcessXlibEventsInit( SingleClick, DoubleClick );
/* Initializing and creating a DockApp window. */
InitDockAppWindow( argc, argv, wmnotify_xpm, wmnotify_infos.display_arg,
wmnotify_infos.geometry_arg );
/* Starting thread for periodically checking for new mail. */
status = pthread_create( &timer_thread, NULL, TimerThread, NULL );
if( status != 0 ) {
fprintf( stderr, "%s: Thread creation failed (%d)\n", PACKAGE, status );
ErrorLocation( __FILE__, __LINE__ );
exit( EXIT_FAILURE );
}
/* Main loop, processing X Events */
ProcessXlibEvents();
/* This code is never reached for now. */
fprintf( stderr, "%s: Program exit\n", PACKAGE );
exit( EXIT_SUCCESS );
}
/*
Windeu initialization
*/
void InitWindeu (int argc, char **argv, char *init_level)
{
TRACE ("InitWindeu(): start");
argv++;
argc--;
// Initialize graphics data (GDI pen cache, ...)
// InitGfxData();
// Init. MainWad file name to default (DOOM.WAD)
MainWad = (char *)GetMemory (strlen(DEFAULT_MAIN_WAD)+1);
strcpy (MainWad, DEFAULT_MAIN_WAD);
// Init. default texture strings
DefaultWallTexture = (char *)GetMemory (strlen(DEFAULT_WALL_TEXTURE)+1);
strcpy (DefaultWallTexture, DEFAULT_WALL_TEXTURE);
DefaultUpperTexture = (char *)GetMemory (strlen(DEFAULT_UPPER_TEXTURE)+1);
strcpy (DefaultUpperTexture, DEFAULT_UPPER_TEXTURE);
DefaultLowerTexture = (char *)GetMemory (strlen(DEFAULT_LOWER_TEXTURE)+1);
strcpy (DefaultLowerTexture, DEFAULT_LOWER_TEXTURE);
DefaultFloorTexture = (char *)GetMemory (strlen(DEFAULT_FLOOR_TEXTURE)+1);
strcpy (DefaultFloorTexture, DEFAULT_FLOOR_TEXTURE);
DefaultCeilingTexture = (char *)GetMemory (strlen(DEFAULT_CEILING_TEXTURE)+1);
strcpy (DefaultCeilingTexture, DEFAULT_CEILING_TEXTURE);
// Init bitmap dir & filespec ARK
BitmapDir = (char *)GetMemory (strlen(DEFAULT_BITMAP_DIR)+1);
strcpy (BitmapDir, DEFAULT_BITMAP_DIR);
BitmapSpec = (char *)GetMemory (strlen(DEFAULT_BITMAP_SPEC)+1);
strcpy (BitmapSpec, DEFAULT_BITMAP_SPEC);
KodDir = (char *)GetMemory (strlen(DEFAULT_KOD_DIR)+1);
strcpy (KodDir, DEFAULT_KOD_DIR);
ServerDir = (char *)GetMemory (strlen(DEFAULT_SERVER_DIR)+1);
strcpy (ServerDir, DEFAULT_SERVER_DIR);
EntranceData = (char*)GetMemory(strlen(DEFAULT_ENTRANCE_FILE)+1);
strcpy (EntranceData, DEFAULT_ENTRANCE_FILE);
/* quick and dirty check for a "-config" option */
for (int i = 0; i < argc - 1; i++)
if (!strcmp(argv[i], "-config"))
{
CfgFile = argv[i + 1];
break;
}
/* read config file and command line options */
ParseConfigFileOptions(CfgFile);
ParseCommandLineOptions(argc, argv, init_level);
// Setup builder priority vars.
if ( BuildPriority < BUILD_PRIORITY_MIN )
BuildPriority = BUILD_PRIORITY_MIN;
if ( BuildPriority > BUILD_PRIORITY_MAX )
BuildPriority = BUILD_PRIORITY_MAX;
// Check grid size value
if ( GridScale >= 256 ) GridScale = 256;
else if ( GridScale >= 128 ) GridScale = 128;
else if ( GridScale >= 64 ) GridScale = 64;
else if ( GridScale >= 32 ) GridScale = 32;
else if ( GridScale >= 16 ) GridScale = 16;
else if ( GridScale >= 8 ) GridScale = 8;
else GridScale = 0;
#if (COOPERATION_VERSION == 1)
BuildCoopExecTab();
#endif // COOPERATION_VERSION
ReadWTextureInfo();
ReadFTextureInfo();
// Disabled 7/04 ARK
// char buffer[_MAX_PATH];
// strcpy(buffer,KodDir);
// strcat(buffer,"Objects.txt");
// LoadKodObjects(buffer);
// strcpy(buffer,KodDir);
// strcat(buffer,"RoomID.txt");
// LoadKodRooms(buffer);
// RoomID = 0;
// OpenEntrances(EntranceData);
LogMessage(": Starting roomedit\n");
}
int main(int argc, char **argv) {
struct opts Options;
int i;
time_t CurrentTime;
clock_t TotalClock = clock();
/* Apply Mondriaan options. */
SetDefaultOptions(&Options);
if (!SetOptionsFromFile(&Options, "Mondriaan.defaults")) {
fprintf(stderr, "main(): warning, cannot set options from 'Mondriaan.defaults', using default options!\n");
}
if (!ParseCommandLineOptions(&Options, argc, argv)) {
fprintf(stderr, "main(): invalid command line parameters!\n");
exit(EXIT_FAILURE);
}
if (!ApplyOptions(&Options)) {
fprintf(stderr, "main(): could not apply given options!\n");
exit(EXIT_FAILURE);
}
if (NumMatrices <= 0 || Matrices == NULL) {
fprintf(stderr, "main(): Invalid number of supplied matrices or samples!\n");
exit(EXIT_FAILURE);
}
/* Start profiling ... */
fprintf(stderr, "Profiling Mondriaan for %d matrices, %d samples, %s processors, and %f imbalance.\n", NumMatrices, NumSamples, argv[1], Options.eps);
for (i = 0; i < NumMatrices*NumNumProcs; ++i) {
int j;
fprintf(stderr, "[% 4d/%d] (% 4ld) %s ", i + 1, NumMatrices*NumNumProcs, Matrices[i].P, Matrices[i].File);
fflush(stderr);
if (!SetupAttributes(&Matrices[i])) {
fprintf(stderr, "main(): Cannot setup attributes!\n");
exit(EXIT_FAILURE);
}
Options.P = Matrices[i].P;
/* Take the requested number of samples. */
for (j = 0; j < NumSamples; ++j) {
struct sparsematrix A;
long int *UAssign, *VAssign, Symmetric;
FILE *File;
long l;
int k;
clock_t Clock;
double Duration;
long MaxNz, MinNz;
long MaxComU, MaxComV, ComVolU, ComVolV;
fprintf(stderr, ".");
fflush(stderr);
/* Read matrix from disk. */
File = fopen(Matrices[i].File, "r");
if (!File) {
fprintf(stderr, "main(): Could not open '%s' for reading!\n", Matrices[i].File);
exit(EXIT_FAILURE);
}
if (!MMReadSparseMatrix(File, &A)) {
fprintf(stderr, "main(): Could not read matrix!\n");
exit(EXIT_FAILURE);
}
fclose(File);
/* Remove double zeroes. */
if (!SparseMatrixRemoveDuplicates(&A)) exit(EXIT_FAILURE);
/* Check symmetry. */
if (A.m == A.n && (A.MMTypeCode[3] == 'S' || A.MMTypeCode[3] == 'K' || A.MMTypeCode[3] == 'H')) Symmetric = TRUE;
else Symmetric = FALSE;
if (Symmetric)
{
if (Options.SymmetricMatrix_UseSingleEntry == SingleEntNo) SparseMatrixSymmetric2Full(&A);
else if (Options.SymmetricMatrix_SingleEntryType == ETypeRandom) SparseMatrixSymmetricLower2Random(&A);
}
/* Add dummies if requested. */
if (A.m == A.n && Options.SquareMatrix_DistributeVectorsEqual == EqVecYes && Options.SquareMatrix_DistributeVectorsEqual_AddDummies == DumYes) AddDummiesToSparseMatrix(&A);
/* Initialise processor array. */
A.NrProcs = Options.P;
A.Pstart = (long *)malloc((A.NrProcs + 1)*sizeof(long));
if (A.Pstart == NULL) {
fprintf(stderr, "main(): Cannot allocate processor array!\n");
exit(EXIT_FAILURE);
}
A.Pstart[0] = 0;
for (k = 1; k <= A.NrProcs; ++k) {
A.Pstart[k] = A.NrNzElts;
}
/* Distribute the processors among the matrix entries. */
SetRandomSeed(Options.Seed = 137*j + 12345);
/* ==== Start Mondriaan */
Clock = clock();
if (!DistributeMatrixMondriaan(&A, Options.P, Options.eps, &Options, NULL)) {
fprintf(stderr, "main(): Unable to distribute matrix!\n");
exit(EXIT_FAILURE);
}
/* Remove dummies. */
if (A.m == A.n && Options.SquareMatrix_DistributeVectorsEqual == EqVecYes && Options.SquareMatrix_DistributeVectorsEqual_AddDummies == DumYes) RemoveDummiesFromSparseMatrix(&A);
/* Convert randomly represented matrix to lower triangular form. */
if (Symmetric && Options.SymmetricMatrix_UseSingleEntry == SingleEntYes && Options.SymmetricMatrix_SingleEntryType == ETypeRandom) SparseMatrixSymmetricRandom2Lower(&A);
/* Distribute vectors. */
UAssign = (long int *)malloc(A.m*sizeof(long int));
VAssign = (long int *)malloc(A.n*sizeof(long int));
if (UAssign == NULL || VAssign == NULL) {
fprintf(stderr, "main(): Cannot allocate vertex assign arrays!\n");
exit(EXIT_FAILURE);
}
/* Convert symmetrically partitioned matrix to full form. */
if (Symmetric && Options.SymmetricMatrix_UseSingleEntry == SingleEntYes) SparseMatrixSymmetric2Full(&A);
if (A.m == A.n && Options.SquareMatrix_DistributeVectorsEqual == EqVecYes) {
if (Symmetric && Options.SymmetricMatrix_UseSingleEntry == SingleEntYes) {
MaxComV = DistributeVec(&A, VAssign, ROW, &Options);
if (MaxComV < 0) {
fprintf(stderr, "main(): Unable to distribute vector!\n");
exit(EXIT_FAILURE);
}
for (k = 0; k < A.m; k++) {
UAssign[k] = VAssign[k];
}
MaxComU = MaxComV;
}
else {
MaxComU = DistributeVecOrigEq(&A, UAssign, VAssign, &Options);
if (MaxComU < 0) {
fprintf(stderr, "main(): Unable to distribute vector!\n");
exit(EXIT_FAILURE);
}
MaxComV = 0;
}
}
else {
MaxComV = DistributeVec(&A, VAssign, ROW, &Options);
MaxComU = DistributeVec(&A, UAssign, COL, &Options);
if (MaxComV < 0 || MaxComU < 0) {
fprintf(stderr, "main(): Unable to distribute vector!\n");
exit(EXIT_FAILURE);
}
}
/* ==== Stop Mondriaan */
/* Calculate duration. */
Duration = (double)(clock() - Clock)/(double)CLOCKS_PER_SEC;
/* Determine minimum and maximum number of assigned nonzeroes. */
MaxNz = MinNz = A.Pstart[1] - A.Pstart[0];
for (k = 1; k < A.NrProcs; ++k) {
l = A.Pstart[k + 1] - A.Pstart[k];
if (l > MaxNz) MaxNz = l;
if (l < MinNz) MinNz = l;
}
/* Calculate communication volume. */
if (!CalcCom(&A, VAssign, ROW, &ComVolV, &l, &l, &l, &l) ||
!CalcCom(&A, UAssign, COL, &ComVolU, &l, &l, &l, &l)) {
fprintf(stderr, "main(): Unable to calculate communication volume!\n");
exit(EXIT_FAILURE);
}
/* Store attributes. */
Matrices[i].NumNz = A.NrNzElts;
Matrices[i].Rows = A.m;
Matrices[i].Cols = A.n;
Matrices[i].Attributes[0].Data[j] = Duration;
Matrices[i].Attributes[1].Data[j] = (double)(Options.P*MaxNz - A.NrNzElts)/(double)A.NrNzElts;
Matrices[i].Attributes[2].Data[j] = (double)(MaxComV + MaxComU);
Matrices[i].Attributes[3].Data[j] = (double)(ComVolV + ComVolU);
/* Free memory. */
MMDeleteSparseMatrix(&A);
free(UAssign);
free(VAssign);
}
/* Average attributes. */
if (!AverageAndFreeAttributes(&Matrices[i])) {
fprintf(stderr, "main(): Cannot setup attributes!\n");
exit(EXIT_FAILURE);
}
fprintf(stderr, "\n");
}
/* Write accumulated data to stdout. */
fprintf(stderr, "Finished profiling, writing data ...\n");
printf("%% Profiled Mondriaan for %d matrices, %d samples, and %f imbalance.\n", NumMatrices, NumSamples, Options.eps);
printf("\\documentclass[a4paper, 10pt]{article}\n\n");
printf("\\usepackage{lscape}\n");
printf("\\usepackage{longtable}\n\n");
printf("\\author{\\texttt{Profile.c}}\n");
CurrentTime = time(NULL);
printf("\\date{%s}\n", asctime(localtime(&CurrentTime)));
printf("\\title{Profiling Mondriaan %s with %d %s}\n\n", MONDRIAANVERSION, NumMatrices, NumMatrices > 1 ? "matrices" : "matrix");
printf("\\begin{document}\n\n");
printf("\\maketitle\n\n");
printf("\\section{Results}\n\n");
printf("Used Mondriaan version %s to distribute %d matrices (listed in table \\ref{MondriaanMatrices}) over %d processors with maximum imbalance %f, taking the average of %d samples. The used options can be found in table \\ref{MondriaanSettings} en the numerical results in table \\ref{MondriaanResults}.\n", MONDRIAANVERSION, NumMatrices, Options.P, Options.eps, NumSamples);
printf("This took %.1f minutes in total.\n\n", (double)(clock() - TotalClock)/(60.0*(double)CLOCKS_PER_SEC));
/* Export options. */
printf("\\begin{table}\n");
printf("\\caption{Mondriaan configuration.}\n");
printf("\\label{MondriaanSettings}\n");
printf("\\begin{center}\n");
if (!ExportOptionsToLaTeX(stdout, &Options)) {
fprintf(stderr, "main(): Unable to create option table!\n");
exit(EXIT_FAILURE);
}
printf("\\end{center}\n");
printf("\\end{table}\n\n");
/* Export list of test matrices. */
printf("\\begin{table}\n");
printf("\\caption{%d tested matrices.}\n", NumMatrices);
printf("\\label{MondriaanMatrices}\n");
printf("\\begin{center}\n");
printf("\\begin{tabular}{l|lll}\nFile & $\\mathit{nz}$ & $m$ & $n$ \\\\\n\\hline\n");
for (i = 0; i < NumMatrices*NumNumProcs; i += NumNumProcs) {
printf("\\verb|%s| & %ld & %ld & %ld \\\\\n", Matrices[i].File, Matrices[i].NumNz, Matrices[i].Rows, Matrices[i].Cols);
}
printf("\\hline\n");
printf("\\end{tabular}\n");
printf("\\end{center}\n");
printf("\\end{table}\n\n");
/* Export test data. */
printf("\\begin{landscape}\n");
printf("\\begin{longtable}{lrrrrr}");
printf("\\caption[Profile results]{Profile results for %d matrices.}\n", NumMatrices);
printf("\\label{MondriaanResults} \\\\\n\n");
printf("\\multicolumn{1}{c}{File} & \\multicolumn{1}{c}{$p$} & \\multicolumn{1}{c}{Time (s)} & \\multicolumn{1}{c}{$\\varepsilon$} & \\multicolumn{1}{c}{Max. com.} & \\multicolumn{1}{c}{Com. vol.} \\\\ \\hline\n");
printf("\\endfirsthead\n\n");
printf("\\multicolumn{6}{c}{\\tablename\\ \\thetable{} -- continued from previous page.} \\\\\n");
printf("\\multicolumn{1}{c}{File} & \\multicolumn{1}{c}{$p$} & \\multicolumn{1}{c}{Time (s)} & \\multicolumn{1}{c}{$\\varepsilon$} & \\multicolumn{1}{c}{Max. com.} & \\multicolumn{1}{c}{Com. vol.} \\\\ \\hline\n");
printf("\\endhead\n\n");
printf("\\multicolumn{6}{c}{Continued on next page.} \\\\\n");
printf("\\endfoot\n\n");
printf("\\hline\n\\endlastfoot\n\n");
for (i = 0; i < NumMatrices*NumNumProcs; i += NumNumProcs) {
int j;
for (j = 0; j < NumNumProcs; ++j) {
char Tmp[256];
const struct sMatrixData *Mat = &Matrices[i + j];
if (j == 0) printf("\\verb|%s| & %ld", Mat->File, Mat->P);
else printf(" & %ld", Mat->P);
/*
int k;
for (k = 0; k < NUM_ATTRIBUTES; ++k) {
char Tmp[256];
DoubleToLaTeX(Tmp, Mat->Attributes[k].Average, 3);
printf(" & $%s \\pm ", Tmp);
DoubleToLaTeX(Tmp, sqrt(Mat->Attributes[k].Variance), 1);
printf("%s$", Tmp);
}
*/
DoubleToLaTeX(Tmp, Mat->Attributes[0].Average, 3);
printf(" & $%s \\pm ", Tmp);
DoubleToLaTeX(Tmp, sqrt(Mat->Attributes[0].Variance), 1);
printf("%s$", Tmp);
DoubleToLaTeX(Tmp, Mat->Attributes[1].Average, 3);
printf(" & $%s$", Tmp);
printf(" & $%ld \\pm %ld$", (long)Mat->Attributes[2].Average, (long)sqrt(Mat->Attributes[2].Variance));
printf(" & $%ld \\pm %ld$", (long)Mat->Attributes[3].Average, (long)sqrt(Mat->Attributes[3].Variance));
printf(" \\\\\n");
}
printf("\\hline\n");
}
printf("\n\\end{longtable}\n");
printf("\\end{landscape}\n\n");
printf("\\end{document}\n\n");
/* Append raw data. */
printf("Raw data:\n");
for (i = 0; i < NumMatrices*NumNumProcs; ++i) {
int j;
printf("%s\t%ld\t%ld\t%ld\t%ld\t", Matrices[i].File, Matrices[i].NumNz, Matrices[i].Rows, Matrices[i].Cols, Matrices[i].P);
for (j = 0; j < NUM_ATTRIBUTES - 1; ++j) printf("%e\t%e\t", Matrices[i].Attributes[j].Average, sqrt(Matrices[i].Attributes[j].Variance));
printf("%e\t%e\n", Matrices[i].Attributes[j].Average, sqrt(Matrices[i].Attributes[j].Variance));
}
printf("\n");
free(Matrices);
fprintf(stderr, "Done!\n");
exit(EXIT_SUCCESS);
}
