Skip to content
Snippets Groups Projects
Commit 6909eab0 authored by Soeren Peters's avatar Soeren Peters
Browse files

Update metis to 5.1.1. 

Update to development of using public libraries.
parent b954951f
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 645 additions and 1203 deletions
3rdParty/metis/metis-5.1.0/CMakeLists.txt deleted 100644 → 0
+ 0
− 27
View file @ b954951f
cmake_minimum_required(VERSION 2.8)
project(METIS)
set(GKLIB_PATH "${PROJECT_SOURCE_DIR}/GKlib" CACHE PATH "path to GKlib")
#set(SHARED FALSE CACHE BOOL "build a shared library")
if(MSVC)
set(METIS_INSTALL FALSE)
else()
set(METIS_INSTALL TRUE)
endif()
# Configure libmetis library.
if(BUILD_SHARED_LIBS)
set(METIS_LIBRARY_TYPE SHARED)
else()
set(METIS_LIBRARY_TYPE STATIC)
endif()
include(${GKLIB_PATH}/GKlibSystem.cmake)
# Add include directories.
include_directories(${GKLIB_PATH})
include_directories(include)
# Recursively look for CMakeLists.txt in subdirs.
add_subdirectory("include")
add_subdirectory("libmetis")
#add_subdirectory("programs")
3rdParty/metis/metis-5.1.0/GKlib/BUILD.txt deleted 100644 → 0
+ 0
− 25
View file @ b954951f
Building GKlib requires CMake 2.8. Once you've installed CMake run
$ make
This will build the GKlib library in build/<arch>/. Options can be tweaked by
running make config. For example,
$ make config openmp=ON
$ make
will build GKlib will OpenMP support if it is available.
GKlib can be installed with
$ make install
and uninstalled with
$ make uninstall
You can choose the installation prefix with make config:
$ make config prefix=~/local
will cause GKlib to be install in the ~/local tree.
3rdParty/metis/metis-5.1.0/GKlib/omp.c deleted 100644 → 0
+ 0
− 27
View file @ b954951f
/*
* Copyright 1997, Regents of the University of Minnesota
*
* omp.c
*
* This file contains "fake" implementations of OpenMP's runtime libraries
*
*/
#include <GKlib.h>
#ifdef GK_NOOPENMP /* remove those for now */
#if !defined(_OPENMP)
void omp_set_num_threads(int num_threads) { return; }
int omp_get_num_threads(void) { return 1; }
int omp_get_max_threads(void) { return 1; }
int omp_get_thread_num(void) { return 0; }
int omp_get_num_procs(void) { return 1; }
int omp_in_parallel(void) { return 0; }
void omp_set_dynamic(int num_threads) { return; }
int omp_get_dynamic(void) { return 0; }
void omp_set_nested(int nested) { return; }
int omp_get_nested(void) { return 0; }
#endif
#endif
3rdParty/metis/metis-5.1.0/GKlib/pdb.c deleted 100644 → 0
+ 0
− 460
View file @ b954951f
/************************************************************************/
/*! \file pdb.c
\brief Functions for parsing pdb files.
Pdb reader (parser). Loads arrays of pointers for easy backbone access.
\date Started 10/20/06
\author Kevin
\version $Id: pdb.c 10711 2011-08-31 22:23:04Z karypis $
*/
/************************************************************************/
#include <GKlib.h>
/************************************************************************/
/*! \brief Converts three-letter amino acid codes to one-leter codes.
This function takes a three letter \c * and converts it to a single \c
\param res is the three-letter code to be converted.
\returns A \c representing the amino acid.
*/
/************************************************************************/
char gk_threetoone(char *res) { /* {{{ */
/* make sure the matching works */
res[0] = toupper(res[0]);
res[1] = toupper(res[1]);
res[2] = toupper(res[2]);
if(strcmp(res,"ALA") == 0) {
return 'A';
}
else if(strcmp(res,"CYS") == 0) {
return 'C';
}
else if(strcmp(res,"ASP") == 0) {
return 'D';
}
else if(strcmp(res,"GLU") == 0) {
return 'E';
}
else if(strcmp(res,"PHE") == 0) {
return 'F';
}
else if(strcmp(res,"GLY") == 0) {
return 'G';
}
else if(strcmp(res,"HIS") == 0) {
return 'H';
}
else if(strcmp(res,"ILE") == 0) {
return 'I';
}
else if(strcmp(res,"LYS") == 0) {
return 'K';
}
else if(strcmp(res,"LEU") == 0) {
return 'L';
}
else if(strcmp(res,"MET") == 0) {
return 'M';
}
else if(strcmp(res,"ASN") == 0) {
return 'N';
}
else if(strcmp(res,"PRO") == 0) {
return 'P';
}
else if(strcmp(res,"GLN") == 0) {
return 'Q';
}
else if(strcmp(res,"ARG") == 0) {
return 'R';
}
else if(strcmp(res,"SER") == 0) {
return 'S';
}
else if(strcmp(res,"THR") == 0) {
return 'T';
}
else if(strcmp(res,"SCY") == 0) {
return 'U';
}
else if(strcmp(res,"VAL") == 0) {
return 'V';
}
else if(strcmp(res,"TRP") == 0) {
return 'W';
}
else if(strcmp(res,"TYR") == 0) {
return 'Y';
}
else {
return 'X';
}
} /* }}} */
/************************************************************************/
/*! \brief Frees the memory of a pdbf structure.
This function takes a pdbf pointer and frees all the memory below it.
\param p is the pdbf structure to be freed.
*/
/************************************************************************/
void gk_freepdbf(pdbf *p) { /* {{{ */
int i;
if(p != NULL) {
gk_free((void **)&p->resSeq, LTERM);
for(i=0; i<p->natoms; i++) {
gk_free((void **)&p->atoms[i].name, &p->atoms[i].resname, LTERM);
}
for(i=0; i<p->nresidues; i++) {
gk_free((void *)&p->threeresSeq[i], LTERM);
}
/* this may look like it's wrong, but it's just a 1-d array of pointers, and
the pointers themselves are freed above */
gk_free((void **)&p->bbs, &p->cas, &p->atoms, &p->cm, &p->threeresSeq, LTERM);
}
gk_free((void **)&p, LTERM);
} /* }}} */
/************************************************************************/
/*! \brief Reads a pdb file into a pdbf structure
This function allocates a pdbf structure and reads the file fname into
that structure.
\param fname is the file name to be read
\returns A filled pdbf structure.
*/
/************************************************************************/
pdbf *gk_readpdbfile(char *fname) { /* {{{ */
int i=0, res=0;
char linetype[6];
int aserial;
char aname[5] = " \0";
char altLoc = ' ';
char rname[4] = " \0";
char chainid = ' ';
char oldchainid = ' ';
int rserial;
int oldRserial = -37;
char icode = ' ';
char element = ' ';
double x;
double y;
double z;
double avgx;
double avgy;
double avgz;
double opcy;
double tmpt;
char line[MAXLINELEN];
int corruption=0;
int nresatoms;
int atoms=0, residues=0, cas=0, bbs=0, firstres=1;
pdbf *toFill = gk_malloc(sizeof(pdbf),"fillme");
FILE *FPIN;
FPIN = gk_fopen(fname,"r",fname);
while(fgets(line, 256, FPIN)) {
sscanf(line,"%s ",linetype);
/* It seems the only reliable parts are through temperature, so we only use these parts */
/* if(strstr(linetype, "ATOM") != NULL || strstr(linetype, "HETATM") != NULL) { */
if(strstr(linetype, "ATOM") != NULL) {
sscanf(line, "%6s%5d%*1c%4c%1c%3c%*1c%1c%4d%1c%*3c%8lf%8lf%8lf%6lf%6lf %c\n",
linetype,&aserial,aname,&altLoc,rname,&chainid,&rserial,&icode,&x,&y,&z,&opcy,&tmpt,&element);
sscanf(linetype, " %s ",linetype);
sscanf(aname, " %s ",aname);
sscanf(rname, " %s ",rname);
if(altLoc != ' ') {
corruption = corruption|CRP_ALTLOCS;
}
if(firstres == 1) {
oldRserial = rserial;
oldchainid = chainid;
residues++;
firstres = 0;
}
if(oldRserial != rserial) {
residues++;
oldRserial = rserial;
}
if(oldchainid != chainid) {
corruption = corruption|CRP_MULTICHAIN;
}
oldchainid = chainid;
atoms++;
if(strcmp(aname,"CA") == 0) {
cas++;
}
if(strcmp(aname,"N") == 0 || strcmp(aname,"CA") == 0 ||
strcmp(aname,"C") == 0 || strcmp(aname,"O") == 0) {
bbs++;
}
}
else if(strstr(linetype, "ENDMDL") != NULL || strstr(linetype, "END") != NULL || strstr(linetype, "TER") != NULL) {
break;
}
}
fclose(FPIN);
/* printf("File has coordinates for %d atoms in %d residues\n",atoms,residues); */
toFill->natoms = atoms;
toFill->ncas = cas;
toFill->nbbs = bbs;
toFill->nresidues = residues;
toFill->resSeq = (char *) gk_malloc (residues*sizeof(char),"residue seq");
toFill->threeresSeq = (char **)gk_malloc (residues*sizeof(char *),"residue seq");
toFill->atoms = (atom *) gk_malloc (atoms*sizeof(atom), "atoms");
toFill->bbs = (atom **)gk_malloc ( bbs*sizeof(atom *),"bbs");
toFill->cas = (atom **)gk_malloc ( cas*sizeof(atom *),"cas");
toFill->cm = (center_of_mass *)gk_malloc(residues*sizeof(center_of_mass),"center of mass");
res=0; firstres=1; cas=0; bbs=0; i=0;
avgx = 0.0; avgy = 0.0; avgz = 0.0;
nresatoms = 0;
FPIN = gk_fopen(fname,"r",fname);
while(fgets(line, 256, FPIN)) {
sscanf(line,"%s ",linetype);
/* It seems the only reliable parts are through temperature, so we only use these parts */
/* if(strstr(linetype, "ATOM") != NULL || strstr(linetype, "HETATM") != NULL) { */
if(strstr(linetype, "ATOM") != NULL ) {
/* to ensure our memory doesn't get corrupted by the biologists, we only read this far */
sscanf(line, "%6s%5d%*1c%4c%1c%3c%*1c%1c%4d%1c%*3c%8lf%8lf%8lf%6lf%6lf %c\n",
linetype,&aserial,aname,&altLoc,rname,&chainid,&rserial,&icode,&x,&y,&z,&opcy,&tmpt,&element);
sscanf(aname, "%s",aname);
sscanf(rname, "%s",rname);
if(firstres == 1) {
toFill->resSeq[res] = gk_threetoone(rname);
toFill->threeresSeq[res] = gk_strdup(rname);
oldRserial = rserial;
res++;
firstres = 0;
}
if(oldRserial != rserial) {
/* we're changing residues. store the center of mass from the last one & reset */
toFill->cm[res-1].x = avgx/nresatoms;
toFill->cm[res-1].y = avgy/nresatoms;
toFill->cm[res-1].z = avgz/nresatoms;
avgx = 0.0; avgy = 0.0; avgz = 0.0;
nresatoms = 0;
toFill->cm[res-1].name = toFill->resSeq[res-1];
toFill->threeresSeq[res] = gk_strdup(rname);
toFill->resSeq[res] = gk_threetoone(rname);
res++;
oldRserial = rserial;
}
avgx += x;
avgy += y;
avgz += z;
nresatoms++;
toFill->atoms[i].x = x;
toFill->atoms[i].y = y;
toFill->atoms[i].z = z;
toFill->atoms[i].opcy = opcy;
toFill->atoms[i].tmpt = tmpt;
toFill->atoms[i].element = element;
toFill->atoms[i].serial = aserial;
toFill->atoms[i].chainid = chainid;
toFill->atoms[i].altLoc = altLoc;
toFill->atoms[i].rserial = rserial;
toFill->atoms[i].icode = icode;
toFill->atoms[i].name = gk_strdup(aname);
toFill->atoms[i].resname = gk_strdup(rname);
/* Set up pointers for the backbone and c-alpha shortcuts */
if(strcmp(aname,"CA") == 0) {
toFill->cas[cas] = &(toFill->atoms[i]);
cas++;
}
if(strcmp(aname,"N") == 0 || strcmp(aname,"CA") == 0 || strcmp(aname,"C") == 0 || strcmp(aname,"O") == 0) {
toFill->bbs[bbs] = &(toFill->atoms[i]);
bbs++;
}
i++;
}
else if(strstr(linetype, "ENDMDL") != NULL || strstr(linetype, "END") != NULL || strstr(linetype, "TER") != NULL) {
break;
}
}
/* get that last average */
toFill->cm[res-1].x = avgx/nresatoms;
toFill->cm[res-1].y = avgy/nresatoms;
toFill->cm[res-1].z = avgz/nresatoms;
/* Begin test code */
if(cas != residues) {
printf("Number of residues and CA coordinates differs by %d (!)\n",residues-cas);
if(cas < residues) {
corruption = corruption|CRP_MISSINGCA;
}
else if(cas > residues) {
corruption = corruption|CRP_MULTICA;
}
}
if(bbs < residues*4) {
corruption = corruption|CRP_MISSINGBB;
}
else if(bbs > residues*4) {
corruption = corruption|CRP_MULTIBB;
}
fclose(FPIN);
toFill->corruption = corruption;
/* if(corruption == 0)
printf("File was clean!\n"); */
return(toFill);
} /* }}} */
/************************************************************************/
/*! \brief Writes the sequence of residues from a pdb file.
This function takes a pdbf structure and a filename, and writes out
the amino acid sequence according to the atomic coordinates. The output
is in fasta format.
\param p is the pdbf structure with the sequence of interest
\param fname is the file name to be written
*/
/************************************************************************/
void gk_writefastafrompdb(pdbf *pb, char *fname) {
int i;
FILE *FPOUT;
FPOUT = gk_fopen(fname,"w",fname);
fprintf(FPOUT,"> %s\n",fname);
for(i=0; i<pb->nresidues; i++)
fprintf(FPOUT,"%c",pb->resSeq[i]);
fprintf(FPOUT,"\n");
fclose(FPOUT);
}
/************************************************************************/
/*! \brief Writes all centers of mass in pdb-format to file fname.
This function takes a pdbf structure and writes out the calculated
mass center information to file fname as though each one was a c-alpha.
\param p is the pdbf structure to write out
\param fname is the file name to be written
*/
/************************************************************************/
void gk_writecentersofmass(pdbf *p, char *fname) {
int i;
FILE *FPIN;
FPIN = gk_fopen(fname,"w",fname);
for(i=0; i<p->nresidues; i++) {
fprintf(FPIN,"%-6s%5d %4s%1c%3s %1c%4d%1c %8.3lf%8.3lf%8.3lf%6.2f%6.2f\n",
"ATOM ",i,"CA",' ',p->threeresSeq[i],' ',i,' ',p->cm[i].x,p->cm[i].y,p->cm[i].z,1.0,-37.0);
}
fclose(FPIN);
}
/************************************************************************/
/*! \brief Writes all atoms in p in pdb-format to file fname.
This function takes a pdbf structure and writes out all the atom
information to file fname.
\param p is the pdbf structure to write out
\param fname is the file name to be written
*/
/************************************************************************/
void gk_writefullatom(pdbf *p, char *fname) {
int i;
FILE *FPIN;
FPIN = gk_fopen(fname,"w",fname);
for(i=0; i<p->natoms; i++) {
fprintf(FPIN,"%-6s%5d %4s%1c%3s %1c%4d%1c %8.3lf%8.3lf%8.3lf%6.2f%6.2f\n",
"ATOM ",p->atoms[i].serial,p->atoms[i].name,p->atoms[i].altLoc,p->atoms[i].resname,p->atoms[i].chainid,p->atoms[i].rserial,p->atoms[i].icode,p->atoms[i].x,p->atoms[i].y,p->atoms[i].z,p->atoms[i].opcy,p->atoms[i].tmpt);
}
fclose(FPIN);
}
/************************************************************************/
/*! \brief Writes out all the backbone atoms of a structure in pdb format
This function takes a pdbf structure p and writes only the backbone atoms
to a filename fname.
\param p is the pdb structure to write out.
\param fname is the file name to be written.
*/
/************************************************************************/
void gk_writebackbone(pdbf *p, char *fname) {
int i;
FILE *FPIN;
FPIN = gk_fopen(fname,"w",fname);
for(i=0; i<p->nbbs; i++) {
fprintf(FPIN,"%-6s%5d %4s%1c%3s %1c%4d%1c %8.3lf%8.3lf%8.3lf%6.2f%6.2f\n",
"ATOM ",p->bbs[i]->serial,p->bbs[i]->name,p->bbs[i]->altLoc,p->bbs[i]->resname,p->bbs[i]->chainid,p->bbs[i]->rserial,p->bbs[i]->icode,p->bbs[i]->x,p->bbs[i]->y,p->bbs[i]->z,p->bbs[i]->opcy,p->bbs[i]->tmpt);
}
fclose(FPIN);
}
/************************************************************************/
/*! \brief Writes out all the alpha carbon atoms of a structure
This function takes a pdbf structure p and writes only the alpha carbon
atoms to a filename fname.
\param p is the pdb structure to write out.
\param fname is the file name to be written.
*/
/************************************************************************/
void gk_writealphacarbons(pdbf *p, char *fname) {
int i;
FILE *FPIN;
FPIN = gk_fopen(fname,"w",fname);
for(i=0; i<p->ncas; i++) {
fprintf(FPIN,"%-6s%5d %4s%1c%3s %1c%4d%1c %8.3lf%8.3lf%8.3lf%6.2f%6.2f\n",
"ATOM ",p->cas[i]->serial,p->cas[i]->name,p->cas[i]->altLoc,p->cas[i]->resname,p->cas[i]->chainid,p->cas[i]->rserial,p->cas[i]->icode,p->cas[i]->x,p->cas[i]->y,p->cas[i]->z,p->cas[i]->opcy,p->cas[i]->tmpt);
}
fclose(FPIN);
}
/************************************************************************/
/*! \brief Decodes the corruption bitswitch and prints any problems
Due to the totally unreliable nature of the pdb format, reading a pdb
file stores a corruption bitswitch, and this function decodes that switch
and prints the result on stdout.
\param p is the pdb structure to write out.
\param fname is the file name to be written.
*/
/************************************************************************/
void gk_showcorruption(pdbf *p) {
int corruption = p->corruption;
if(corruption&CRP_ALTLOCS)
printf("Multiple coordinate sets for at least one atom\n");
if(corruption&CRP_MISSINGCA)
printf("Missing coordiantes for at least one CA atom\n");
if(corruption&CRP_MISSINGBB)
printf("Missing coordiantes for at least one backbone atom (N,CA,C,O)\n");
if(corruption&CRP_MULTICHAIN)
printf("File contains coordinates for multiple chains\n");
if(corruption&CRP_MULTICA)
printf("Multiple CA atoms found for the same residue (could be alternate locators)\n");
if(corruption&CRP_MULTICA)
printf("Multiple copies of backbone atoms found for the same residue (could be alternate locators)\n");
}
/* sscanf(line, "%6s%5d%*1c%4s%1c%3s%*1c%1c%4d%1c%*3c%8lf%8lf%8lf%6lf%6lf%*6c%4s%2s%2s\n",
linetype,&aserial,aname,&altLoc,rname,&chainid,&rserial,&icode,&x,&y,&z,&opcy,&tmpt,segId,element,charge);
printf(".%s.%s.%s.\n",segId,element,charge);
printf("%-6s%5d%-1s%-4s%1c%3s%1s%1c%4d%1c%3s%8.3lf%8.3lf%8.3lf%6.2f%6.2f%6s%4s%2s%2s\n",
linetype,aserial," ",aname,altLoc,rname," ",chainid,rserial,icode," ",x,y,z,opcy,tmpt," ",segId,element,charge); */
/* and we could probably get away with this using astral files, */
/* sscanf(line, "%6s%5d%*1c%4s%1c%3s%*1c%1c%4d%1c%*3c%8lf%8lf%8lf%6lf%6lf%*6c%6s\n",
linetype,&aserial,aname,&altLoc,rname,&chainid,&rserial,&icode,&x,&y,&z,&opcy,&tmpt,element);
printf("%-6s%5d%-1s%-4s%1c%3s%1s%1c%4d%1c%3s%8.3lf%8.3lf%8.3lf%6.2f%6.2f%6s%6s\n",
linetype,aserial," ",aname,altLoc,rname," ",chainid,rserial,icode," ",x,y,z,opcy,tmpt," ",element); */
3rdParty/metis/metis-5.1.0/GKlib/test/Makefile.in.old deleted 100644 → 0
+ 0
− 258
View file @ b954951f
#*************************************************************************
# Global flags
#*************************************************************************
gdb = yes
debug = no
memdbg = no
openmp = no
x86compiler = gcc
VERNUM = 0.1.0
#*************************************************************************
# System-specific compilation flags
#*************************************************************************
# Get some basic information about the system that you are working on
cputype = $(shell uname -m | sed "s/\\ /_/g")
systype = $(shell uname)
ifeq ($(findstring CYGWIN, $(systype)),CYGWIN)
# systype = CYGWIN
systype = MSWIN
cputype = x86
endif
GKLIBINCDIR = $(HOME)/work/algorithms/GKlib/trunk/
GKLIBBUILDDIR = $(HOME)/work/algorithms/GKlib/builds/$(systype)-$(cputype)
ifeq ($(systype),MSWIN)
#-------------------------------------------------------------------
# These defs are very much Visual Studio Specific
#-------------------------------------------------------------------
#Compiler information
CC = cl
OPTFLAGS = /Ox
COPTIONS = -DWIN32 -DMSC -D_CRT_SECURE_NO_DEPRECATE
#Compile input/output file specification
SOURCEFILE = /c $<
OUTPUTFILE = /Fo$@
#Output specification for executables
EXEOUTPUTFILE = /Fe$@ # This option is when cl is used for linking
#EXEOUTPUTFILE = /OUT:$@ # This option is used when link is used for linking
#Linker information
LDOPTIONS = /MT
#LD = /cygdrive/c/Program\ Files/Microsoft\ Visual\ Studio\ 8/VC/BIN/link
LD = cl
MERGEMANIFEST =
#Library creation information
AR = lib /OUT:$@
RANLIB =
ifeq ($(openmp),yes)
COPTIONS += -D__OPENMP__ /openmp
LDOPTIONS += /openmp
MERGEMANIFEST = vc_mt -manifest $@.manifest -outputresource:$@\;1
endif
#Library information
ifeq ($(cputype),i386)
LIBPLOTDIR = ../Libplot/Win32
else
LIBPLOTDIR = ../Libplot/Win64
endif
LIBS = $(LIBPLOTDIR)/libplot.lib $(BUILDDIR)/libcluto.lib $(GKLIBBUILDDIR)/libGKlib.lib
# Standard file extensions
OBJEXT = .obj
LIBEXT = .lib
EXEEXT = .exe
else
ifeq ($(systype),Linux)
ifeq ($(x86compiler),gcc)
#Compiler information
CC = gcc
OPTFLAGS = -O6
COPTIONS = -DLINUX -D_FILE_OFFSET_BITS=64 -pedantic -std=c99 -pthread
#Linker information
LDOPTIONS =
LD = gcc
MERGEMANIFEST =
#Library creation information
AR = ar rv
RANLIB = ar -ts
else
#Compiler information
CC = icc
OPTFLAGS = -O3
COPTIONS = -DLINUX -D_FILE_OFFSET_BITS=64 -std=c99
#Linker information
LDOPTIONS =
LD = icc
#Library creation information
AR = ar rv
RANLIB = ar -ts
ifeq ($(openmp),yes)
COPTIONS += -D__OPENMP__ -openmp -openmp-report2
LDOPTIONS += -openmp
endif
endif
#Library information
ifeq ($(cputype),x86_64)
LIBPLOTDIR = ../Libplot/Linux64
else
LIBPLOTDIR = ../Libplot/Linux32
endif
endif
ifeq ($(systype),SunOS)
#Compiler information
CC = /opt/SUNWspro/bin/cc
OPTFLAGS = -xO4
COPTIONS =-DSUNOS
#Linker information
LDOPTIONS =
LD = /opt/SUNWspro/bin/cc
#Library creation information
AR = ar rv
RANLIB = ar -ts
#Library information
LIBPLOTDIR = ../Libplot/SunOS
endif
ifeq ($(systype),Darwin)
#Compiler information
CC = gcc
OPTFLAGS = -O6
COPTIONS = -DDARWIN -D_FILE_OFFSET_BITS=64 -pedantic -std=c99
#Linker information
LDOPTIONS = -fvisibility=default
LD = gcc
#Library creation information
AR = ar rv
RANLIB = ar -ts
#Library information
ifeq ($(cputype),i386)
LIBPLOTDIR = ../Libplot/Darwini386
else
LIBPLOTDIR = ../Libplot/DarwinPPC
endif
endif
ifeq ($(systype),CYGWIN)
#Compiler information
CC = gcc
OPTFLAGS = -O6
COPTIONS = -DCYGWIN -DWIN32 -D_FILE_OFFSET_BITS=64 -Wall -std=c99 -pedantic -mno-cygwin
#Linker information
LDOPTIONS = -mno-cygwin
LD = gcc
#Library creation information
AR = ar crv
RANLIB = ar -ts
#Library information
LIBPLOTDIR = ../Libplot/CYGWIN
endif
#-------------------------------------------------------------------
# These defs are common among the GNU/GCC based systems
#-------------------------------------------------------------------
#Compile input/output file specification
SOURCEFILE = -c $<
OUTPUTFILE = -o $@
#Output specification for executables
EXEOUTPUTFILE = -o $@
#Library creation information
AR = ar crv $@
RANLIB = ar -ts $@
#Libraries needed for linking
LIBSDIR = -L$(BUILDDIR) -L$(GKLIBBUILDDIR) -L$(HOME)/local/lib
LIBS = -lGKlib -lpcreposix -lpcre -lz -lm
# Standard file extensions
OBJEXT = .o
LIBEXT = .a
EXEEXT =
endif
#**************************************************************************
DMALLOCINC =
DMALLOCFLAGS =
DEBUGFLAGS =
ifeq ($(dmalloc),yes)
DMALLOCINC = -I$(HOME)/local/include
DMALLOCFLAGS = -DDMALLOC
OPTFLAGS = -g
endif
ifeq ($(debug),yes)
DEBUGFLAGS = -DDEBUG
OPTFLAGS = -g
endif
ifeq ($(gdb),yes)
OPTFLAGS += -g
endif
#**************************************************************************
#**************************************************************************
# Create the build directory if it does not exist
#**************************************************************************
ifeq ($(systype),Darwin)
BINDIR = $(HOME)
else
BINDIR = $(HOME)/work/bin/$(systype)-$(cputype)
$(shell mkdir -p $(BINDIR))
endif
ifeq ($(openmp),no)
BUILDDIR = ./builds/$(systype)-$(cputype)
else
BUILDDIR = ./builds/$(systype)-$(cputype)-openmp
endif
LIBBUILDDIR = $(BUILDDIR)/lib
PRGBUILDDIR = $(BUILDDIR)/prg
$(shell mkdir -p $(BUILDDIR))
$(shell mkdir -p $(LIBBUILDDIR))
$(shell mkdir -p $(PRGBUILDDIR))
INCLUDES = -I./ -I$(GKLIBINCDIR) -I$(LIBPLOTDIR) -I$(HOME)/local/include
CFLAGS = $(COPTIONS) $(OPTFLAGS) $(DEBUGFLAGS) $(INCLUDES)
3rdParty/metis/metis-5.1.0/GKlib/test/Makefile.old deleted 100644 → 0
+ 0
− 39
View file @ b954951f
include Makefile.in
STRINGSOBJS = $(PRGBUILDDIR)/strings$(OBJEXT)
GKSORTOBJS = $(PRGBUILDDIR)/gksort$(OBJEXT)
FISOBJS = $(PRGBUILDDIR)/fis$(OBJEXT)
HEADERS = $(wildcard $(GKLIBINCDIR)/*.h)
default: $(BUILDDIR)/strings$(EXEEXT) $(BUILDDIR)/gksort$(EXEEXT) $(BUILDDIR)/fis$(EXEEXT)
$(BUILDDIR)/strings$(EXEEXT): $(STRINGSOBJS) $(GKLIBBUILDDIR)/libGKlib.a
$(LD) $(LDOPTIONS) $(EXEOUTPUTFILE) $(STRINGSOBJS) $(LIBSDIR) $(LIBS) ; $(MERGEMANIFEST)
chmod 744 $@
$(BUILDDIR)/gksort$(EXEEXT): $(GKSORTOBJS) $(GKLIBBUILDDIR)/libGKlib.a
$(LD) $(LDOPTIONS) $(EXEOUTPUTFILE) $(GKSORTOBJS) $(LIBSDIR) $(LIBS) ; $(MERGEMANIFEST)
chmod 744 $@
$(BUILDDIR)/fis$(EXEEXT): $(FISOBJS) $(GKLIBBUILDDIR)/libGKlib.a
$(LD) $(LDOPTIONS) $(EXEOUTPUTFILE) $(FISOBJS) $(LIBSDIR) $(LIBS) ; $(MERGEMANIFEST)
chmod 744 $@
clean:
rm -rf $(PRGBUILDDIR)
realclean:
rm -rf $(PRGBUILDDIR) ;\
rm -rf $(BUILDDIR) ;
$(STRINGSOBJS) : $(HEADERS) Makefile.in Makefile $(GKLIBBUILDDIR)/libGKlib.a
$(PRGBUILDDIR)/%$(OBJEXT) : %.c
$(CC) $(CFLAGS) $(SOURCEFILE) $(OUTPUTFILE)
3rdParty/metis/metis-5.1.0/GKlib/test/gkgraph.c deleted 100644 → 0
+ 0
− 351
View file @ b954951f
/*!
\file
\brief A simple frequent itemset discovery program to test GKlib's routines
\date 6/12/2008
\author George
\version \verbatim $Id: gkgraph.c 11408 2012-01-25 15:05:58Z karypis $ \endverbatim
*/
#include <GKlib.h>
/*************************************************************************/
/*! Data structures for the code */
/*************************************************************************/
typedef struct {
int type;
int niter;
float eps;
float lamda;
char *infile;
char *outfile;
} params_t;
/*************************************************************************/
/*! Constants */
/*************************************************************************/
#define CMD_NITER 1
#define CMD_EPS 2
#define CMD_LAMDA 3
#define CMD_TYPE 4
#define CMD_HELP 10
/*************************************************************************/
/*! Local variables */
/*************************************************************************/
static struct gk_option long_options[] = {
{"type", 1, 0, CMD_TYPE},
{"niter", 1, 0, CMD_NITER},
{"lamda", 1, 0, CMD_LAMDA},
{"eps", 1, 0, CMD_EPS},
{"help", 0, 0, CMD_HELP},
{0, 0, 0, 0}
};
/*-------------------------------------------------------------------*/
/* Mini help */
/*-------------------------------------------------------------------*/
static char helpstr[][100] = {
" ",
"Usage: gkgraph [options] <graph-file> [<out-file>]",
" ",
" Required parameters",
" graph-file",
" The name of the file storing the graph. The file is in ",
" Metis' graph format.",
" ",
" Optional parameters",
" -niter=int",
" Specifies the maximum number of iterations. [default: 100]",
" ",
" -lamda=float",
" Specifies the follow-the-adjacent-links probability. [default: 0.80]",
" ",
" -eps=float",
" Specifies the error tollerance. [default: 1e-10]",
" ",
" -help",
" Prints this message.",
""
};
static char shorthelpstr[][100] = {
" ",
" Usage: gkgraph [options] <graph-file> [<out-file>]",
" use 'gkgraph -help' for a summary of the options.",
""
};
/*************************************************************************/
/*! Function prototypes */
/*************************************************************************/
double compute_compactness(params_t *params, gk_graph_t *graph, int32_t *perm);
void reorder_centroid(params_t *params, gk_graph_t *graph, int32_t *perm);
void print_init_info(params_t *params, gk_graph_t *graph);
void print_final_info(params_t *params);
params_t *parse_cmdline(int argc, char *argv[]);
/*************************************************************************/
/*! the entry point */
/**************************************************************************/
int main(int argc, char *argv[])
{
ssize_t i, j, v;
params_t *params;
gk_graph_t *graph, *pgraph;
int32_t *perm;
/* get command-line options */
params = parse_cmdline(argc, argv);
/* read the data */
graph = gk_graph_Read(params->infile, GK_GRAPH_FMT_METIS, 0, 0, 0);
/* display some basic stats */
print_init_info(params, graph);
/* determine the initial compactness of the graph */
printf("Initial compactness: %le\n", compute_compactness(params, graph, NULL));
/* compute the BFS ordering and re-order the graph */
//for (i=0; i<params->niter; i++) {
for (i=0; i<1; i++) {
v = RandomInRange(graph->nvtxs);
gk_graph_ComputeBFSOrdering(graph, v, &perm, NULL);
printf("BFS from %8d. Compactness: %le\n",
(int) v, compute_compactness(params, graph, perm));
pgraph = gk_graph_Reorder(graph, perm, NULL);
gk_graph_Write(pgraph, "bfs.metis", GK_GRAPH_FMT_METIS);
gk_graph_Free(&pgraph);
gk_graph_ComputeBestFOrdering(graph, v, params->type, &perm, NULL);
printf("BestF from %8d. Compactness: %le\n",
(int) v, compute_compactness(params, graph, perm));
pgraph = gk_graph_Reorder(graph, perm, NULL);
gk_graph_Write(pgraph, "bestf.metis", GK_GRAPH_FMT_METIS);
gk_graph_Free(&pgraph);
#ifdef XXX
for (j=0; j<params->niter; j++) {
reorder_centroid(params, graph, perm);
printf("\tAfter centroid; Compactness: %le\n",
compute_compactness(params, graph, perm));
}
pgraph = gk_graph_Reorder(graph, perm, NULL);
gk_graph_Write(pgraph, "centroid.metis", GK_GRAPH_FMT_METIS);
gk_graph_Free(&pgraph);
#endif
gk_free((void **)&perm, LTERM);
}
gk_graph_Free(&graph);
//gk_graph_Free(&pgraph);
print_final_info(params);
}
/*************************************************************************/
/*! This function computes the compactness of the graph's adjacency list */
/*************************************************************************/
double compute_compactness(params_t *params, gk_graph_t *graph, int32_t *perm)
{
int i, v, u, nvtxs;
ssize_t j, *xadj;
int32_t *adjncy;
double compactness=0.0;
int *freq;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
freq = gk_ismalloc(nvtxs, 0, "compute_compactness: freq");
for (i=0; i<nvtxs; i++) {
v = (perm == NULL ? i : perm[i]);
for (j=xadj[i]; j<xadj[i+1]; j++) {
u = (perm == NULL ? adjncy[j] : perm[adjncy[j]]);
compactness += fabs(v-u);
freq[gk_abs(v-u)]++;
}
}
/*
for (i=0; i<nvtxs; i++) {
if (freq[i] > 0)
printf("%7d %6d\n", i, freq[i]);
}
*/
printf("\tnsmall: %d\n", freq[1]+freq[2]+freq[3]);
return compactness/xadj[nvtxs];
}
/*************************************************************************/
/*! This function uses a centroid-based approach to refine the ordering */
/*************************************************************************/
void reorder_centroid(params_t *params, gk_graph_t *graph, int32_t *perm)
{
int i, v, u, nvtxs;
ssize_t j, *xadj;
int32_t *adjncy;
gk_fkv_t *cand;
double displacement;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
cand = gk_fkvmalloc(nvtxs, "reorder_centroid: cand");
for (i=0; i<nvtxs; i++) {
v = perm[i];
displacement = 0.0;
for (j=xadj[i]; j<xadj[i+1]; j++) {
u = perm[adjncy[j]];
displacement += u-v;
//displacement += sign(u-v, sqrt(fabs(u-v)));
}
cand[i].val = i;
cand[i].key = v + displacement*params->lamda/(xadj[i+1]-xadj[i]);
}
/* sort them based on the target position in increasing order */
gk_fkvsorti(nvtxs, cand);
/* derive the permutation from the ordered list */
gk_i32set(nvtxs, -1, perm);
for (i=0; i<nvtxs; i++) {
if (perm[cand[i].val] != -1)
errexit("Resetting perm[%d] = %d\n", cand[i].val, perm[cand[i].val]);
perm[cand[i].val] = i;
}
gk_free((void **)&cand, LTERM);
}
/*************************************************************************/
/*! This function prints run parameters */
/*************************************************************************/
void print_init_info(params_t *params, gk_graph_t *graph)
{
printf("*******************************************************************************\n");
printf(" gkgraph\n\n");
printf("Graph Information ----------------------------------------------------------\n");
printf(" input file=%s, [%d, %zd]\n",
params->infile, graph->nvtxs, graph->xadj[graph->nvtxs]);
printf("\n");
printf("Options --------------------------------------------------------------------\n");
printf(" type=%d, niter=%d, lamda=%f, eps=%e\n",
params->type, params->niter, params->lamda, params->eps);
printf("\n");
printf("Working... -----------------------------------------------------------------\n");
}
/*************************************************************************/
/*! This function prints final statistics */
/*************************************************************************/
void print_final_info(params_t *params)
{
printf("\n");
printf("Memory Usage Information -----------------------------------------------------\n");
printf(" Maximum memory used: %10zd bytes\n", (ssize_t) gk_GetMaxMemoryUsed());
printf(" Current memory used: %10zd bytes\n", (ssize_t) gk_GetCurMemoryUsed());
printf("********************************************************************************\n");
}
/*************************************************************************/
/*! This is the entry point of the command-line argument parser */
/*************************************************************************/
params_t *parse_cmdline(int argc, char *argv[])
{
int i;
int c, option_index;
params_t *params;
params = (params_t *)gk_malloc(sizeof(params_t), "parse_cmdline: params");
/* initialize the params data structure */
params->type = 1;
params->niter = 1;
params->eps = 1e-10;
params->lamda = 0.20;
params->infile = NULL;
/* Parse the command line arguments */
while ((c = gk_getopt_long_only(argc, argv, "", long_options, &option_index)) != -1) {
switch (c) {
case CMD_TYPE:
if (gk_optarg) params->type = atoi(gk_optarg);
break;
case CMD_NITER:
if (gk_optarg) params->niter = atoi(gk_optarg);
break;
case CMD_EPS:
if (gk_optarg) params->eps = atof(gk_optarg);
break;
case CMD_LAMDA:
if (gk_optarg) params->lamda = atof(gk_optarg);
break;
case CMD_HELP:
for (i=0; strlen(helpstr[i]) > 0; i++)
printf("%s\n", helpstr[i]);
exit(0);
break;
case '?':
default:
printf("Illegal command-line option(s)\nUse %s -help for a summary of the options.\n", argv[0]);
exit(0);
}
}
if (argc-gk_optind != 1) {
printf("Unrecognized parameters.");
for (i=0; strlen(shorthelpstr[i]) > 0; i++)
printf("%s\n", shorthelpstr[i]);
exit(0);
}
params->infile = gk_strdup(argv[gk_optind++]);
if (argc-gk_optind > 0)
params->outfile = gk_strdup(argv[gk_optind++]);
else
params->outfile = gk_strdup("gkgraph.out");
if (!gk_fexists(params->infile))
errexit("input file %s does not exist.\n", params->infile);
return params;
}
3rdParty/metis/metis-5.1.1/CMakeLists.txt 0 → 100644
+ 43
− 0
View file @ 6909eab0
cmake_minimum_required(VERSION 3.0)
project(METIS C)
set(GKLIB_PATH "${CMAKE_CURRENT_SOURCE_DIR}/GKlib")
# Configure libmetis library.
if(BUILD_SHARED_LIBS)
set(METIS_LIBRARY_TYPE SHARED)
else()
set(METIS_LIBRARY_TYPE STATIC)
endif()
include(${GKLIB_PATH}/GKlibSystem.cmake)
# METIS' custom options
option(METIS_IDX64 "enable 64 bit ints" OFF)
option(METIS_REAL64 "enable 64 bit floats (i.e., double)" OFF)
if(METIS_IDX64)
set(METIS_COPTIONS_IDX "-DIDXTYPEWIDTH=64")
else()
set(METIS_COPTIONS_IDX "-DIDXTYPEWIDTH=32")
endif()
if(METIS_REAL64)
set(METIS_COPTIONS_REAL "-DREALTYPEWIDTH=64")
else()
set(METIS_COPTIONS_REAL "-DREALTYPEWIDTH=32")
endif()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${METIS_COPTIONS_IDX} ${METIS_COPTIONS_REAL}")
add_subdirectory("libmetis")
target_include_directories(metis PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/libmetis)
target_include_directories(metis PRIVATE ${GKLIB_PATH})
target_include_directories(metis PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
target_compile_definitions(metis PUBLIC ${METIS_COPTIONS_IDX})
target_compile_definitions(metis PUBLIC ${METIS_COPTIONS_REAL})
groupTarget(metis ${thirdFolder})
\ No newline at end of file
3rdParty/metis/metis-5.1.1/Changelog 0 → 100644
+ 286
− 0
View file @ 6909eab0
metis-5.1.0
------------------------------------------------------------------------
r13937 | karypis | 2013-03-29 23:08:21 -0500 (Fri, 29 Mar 2013)
- Further extended the 2-hop coarsening scheme introduced in 5.0.2 for
for graphs with highly variable degree distribution (e.g., power-law).
This coarsening scheme is automatically used when the standard
1-hop-based scheme leaves a large fraction of the vertices of the
graph unmatched. It leads to better quality partitionings, lower
memory utilization, and faster execution time. In principle, this
scheme will never be triggered for graphs/matrices appearing in
scientific computations derived from FE meshes. However, if you
notice that the quality of the solutions is significantly worse,
this 2-hop matching can be turned off by using the '-no2hop' command
line option and the associated options[] parameter (as described
in the manual).
- Fixed 0/1 numbering issue with mesh partitioning routines (flyspray
issue #109)
metis-5.0.3
------------------------------------------------------------------------
r13822 | karypis | 2013-03-11 14:40:11 -0500 (Mon, 11 Mar 2013)
- Fixed the bug that was introduced in 5.x for creating nodal graphs
from meshes (flyspray issue #107).
- Changed the license to Apache Version 2.
metis-5.0.2
------------------------------------------------------------------------
r10974 | karypis | 2011-10-29 18:24:32 -0500 (Sat, 29 Oct 2011)
- Fixed issue with high-degree vertices and mask-based compression.
- Fixed issue with wrong COARSENING_FRACTION.
- Modified coarsening schemes to better support non FE graphs.
metis-5.0.1
------------------------------------------------------------------------
r10709 | karypis | 2011-08-31 16:07:57 -0500 (Wed, 31 Aug 2011)
- Fixed critical bug in the mesh partitioning routines.
metis-5.0
------------------------------------------------------------------------
r10667 | karypis | 2011-08-04 00:35:30 -0500 (Thu, 04 Aug 2011)
- Updated/corrected error messages.
- Addressed some build issues.
metis-5.0rc3
------------------------------------------------------------------------
r10560 | karypis | 2011-07-13 08:19:10 -0500 (Wed, 13 Jul 2011)
- Fixed various bugs that were identified by testers.
- Some minor performance and quality improvements.
- Addressed some build issues.
metis-5.0rc2
------------------------------------------------------------------------
r10496 | karypis | 2011-07-06 11:04:45 -0500 (Wed, 06 Jul 2011)
- Various run-time and quality optimizations.
- Option error-checking.
- Signal-based heap cleanup on error. Metis API routines will not
return nicely and cleanup all memory that may have allocated.
- Reduced memory requirements.
- Fixed various bugs identified in rc1.
- Added back Fortran support in the form of alternate API names
(see libmetis/frename.h).
- Minor code changes to accommodate ParMetis 4.0.
metis-5.0rc1
------------------------------------------------------------------------
r10227 | karypis | 2011-06-13 23:35:05 -0500 (Mon, 13 Jun 2011)
- A nearly complete re-write of Metis' code-based that changed expanded
the functionality of the command-line programs and API routines.
- Multi-constraint partitioning can be used in conjunction with
minimization of the total communication volume.
- All graph and mesh partitioning routines take as input the target
sizes of the partitions, which among others, allow them to compute
partitioning solutions that are well-suited for parallel architectures
with heterogeneous computing capabilities.
- When multi-constraint partitioning is used, the target sizes of the
partitions are specified on a per partition-constraint pair.
- The multilevel k-way partitioning algorithms can compute a
partitioning solution in which each partition is contiguous.
- All partitioning and ordering routines can compute multiple different
solutions and select the best as the final solution.
- The mesh partitioning and mesh-to-graph conversion routines can
operate on mixed element meshes.
- The command-line programs provide full access to the entire set of
capabilities provided by Metis' API.
- Re-written the memory management subsystem to reduce overall memory
requirements.
metis-5.0pre2
------------------------------------------------------------------------
r1437 | karypis | 2007-04-07 23:16:16 -0500 (Sat, 07 Apr 2007)
- Added installation instructions and change-logs.
- Tested 32bit & 64bit on 64bit architectures and passed tests.
- Tested 32bit on 32bit architectures and passed tests.
- strtoidx() addition for portable input file parsing
- Restructured the internal memory allocation schemes for graph and
refinement data. This should enhance portability and make the code
easier to maintain.
- Fixed some bad memory allocation calls (i.e., sizeof(x)/sizeof(idxtype).
However, there are tons of those and need to be corrected once and for
all by eliminating workspace and the associated mallocs.
- Added mprint/mscanf family of functions for portable formated I/O
of the idxtype datatype. The specifier for this datatype is %D.
All library routines use this function for printing.
The implementation of these routines is not very efficient, but
that should do for now (in principle these routines should not be
used unless debugging).
- Incorporated GKlib into METIS, which replaced many of its internal
functions. GKlib's malloc interface will enable graceful and clean
aborts (i.e., free all internally allocated memory) on fatal errors.
This will probably be available in the next pre-release.
- Fixed the problems associated with metis.h that were identified by
David (flyspray Issue #9).
METIS 4.0.2, 3/10/04
------------------------------------------------------------------------------
- Fixed a problem with weighted graphs and ometis.c
METIS 4.0.1, 11/29/98
------------------------------------------------------------------------------
This is mostly a bug-fix release
- Fixed some bugs in the multi-constraint partitioning routines
- Fixed some bugs in the volume-minimization routines
METIS 4.0.0, 9/20/98
------------------------------------------------------------------------------
METIS 4.0 contains a number of changes over the previous major release (ver
3.0.x). Most of these changes are concentrated on the graph and mesh
partitioning routines and they do not affect the sparse matrix re-ordering
routines. Here is a list of the major changes:
Multi-Constraint Partitioning
-----------------------------
METIS now includes partitioning routines that can be used to a partition
a graph in the presence of multiple balancing constraints.
Minimizing the Total Communication Volume
-----------------------------------------
METIS now includes partitioning routines whose objective is to minimize
the total communication volume (as opposed to minimizing the edge-cut).
Minimizing the Maximum Connectivity of the Subdomains
-----------------------------------------------------
The k-way partitioning routines in METIS can now directly minimize the number
of adjacent subdomains. For most graphs corresponding to finite element
meshes, METIS is able to significantly reduce the maximum (and total) number of
adjacent subdomains.
METIS 3.0.6, 1/28/98
-------------------------------------------------------------------------------
- Fixed some problems when too many partitions were asked, and each partition
end up having 0 vertices
- Fixed some bugs in the I/O routines
- Added support for the g77 compiler under Linux
METIS 3.0.5, 12/22/97
-------------------------------------------------------------------------------
- Fixed problems on 64-bit architectures (eg., -64 option on SGIs).
- Added some options in Makefile.in
METIS 3.0.4, 12/1/97
-------------------------------------------------------------------------------
Fixed a memory leak in the ordering code.
METIS 3.0.3, 11/5/97
-------------------------------------------------------------------------------
This is mostly a bug-fix release with just a few additions
Added functionality
- Added support for quadrilateral elements.
- Added a routine METIS_EstimateMemory that estimates the amount of
memory that will be allocated by METIS. This is useful in determining
if a problem can run on your system.
- Added hooks to allow PARMETIS to use the orderings produced by METIS.
This is hidden from the user but it will be used in the next release
of PARMETIS.
Bug-fixes
- Fixed a bug related to memory allocation. This should somewhat reduce the
overall memory used by METIS.
- Fixed some bugs in the 'graphchk' program in the case of weighted graphs.
- Removed some code corresponding to unused options.
- Fixed some minor bugs in the node-refinement code
-------------------------------------------------------------------------------
METIS 3.0 contains a number of changes over METIS 2.0.
The major changes are the following:
General Changes
---------------
1. Added code to directly partition finite element meshes.
2. Added code to convert finite element meshes into graphs so they
can be used by METIS.
1. The names, calling sequences, and options of the routines in
METISlib have been changed.
2. Better support has been added for Fortran programs.
3. Eliminated the 'metis' program. The only way to tune METIS's
behavior is to use METISlib.
4. Improved memory management. METIS should now only abort if truly
there is no more memory left in the system.
Graph Partitioning
------------------
1. Added partitioning routines that can be used to compute a partition
with prescribed partition weights. For example, they can be used to
compute a 3-way partition such that partition 1 has 50% of the weight,
partition 2 has 20% of the way, and partition 3 has 30% of the weight.
2. Improved the speed of the k-way partitioning algorithm (kmetis). The
new code has better cache locality which dramatically improves the
speed for large graphs. A factor of 4 speedup can be obtained for
certain graphs. METIS can now partition a 4 million node graph
in well under a minute on a MIPS R10000.
3. Eliminated some of the options that were seldom used.
Fill-Reducing Orderings
----------------------
1. Added a node based ordering code `onmetis' that greatly improves
ordering quality.
2. Improved the quality of the orderings produced by the original
edge-based ordering code (it is now called 'oemetis').
3. METIS can now analyze the graph and try to compress together
nodes with identical sparsity pattern. For some problems, this
significantly reduces ordering time
4. METIS can now prune dense columns prior to ordering. This can be
helpful for LP matrices.
Mesh Partitioning
-----------------
1. METIS can now directly partition the element node array of finite
element meshes. It produces two partitioning vectors. One for the
elements and one for the nodes. METIS supports the following
elements: triangles, tetrahedra, hexahedra
Mesh-To-Graph Conversion Routines
---------------------------------
1. METIS now includes a number of mesh conversion functions that can
be used to create the dual and nodal graphs directly from the
element connectivity arrays. These are highly optimized routines.
3rdParty/metis/metis-5.1.1/GKlib/.gitignore 0 → 100644
+ 57
− 0
View file @ 6909eab0
# Prerequisites
*.d
# Object files
*.o
*.ko
*.obj
*.elf
# Linker output
*.ilk
*.map
*.exp
# Precompiled Headers
*.gch
*.pch
# Libraries
*.lib
*.a
*.la
*.lo
# Shared objects (inc. Windows DLLs)
*.dll
*.so
*.so.*
*.dylib
# Executables
*.exe
*.out
*.app
*.i*86
*.x86_64
*.hex
# Debug files
*.dSYM/
*.su
*.idb
*.pdb
# Kernel Module Compile Results
*.mod*
*.cmd
.tmp_versions/
modules.order
Module.symvers
Mkfile.old
dkms.conf
# GK things
build/
lib/
.svn/
3rdParty/metis/metis-5.1.0/GKlib/CMakeLists.txt → 3rdParty/metis/metis-5.1.1/GKlib/CMakeLists.txt
+ 31
− 0
View file @ 6909eab0
cmake_minimum_required(VERSION 2.8)
project(GKlib)
project(GKlib C)
option(BUILD_SHARED_LIBS "Build shared libraries (.dll/.so) instead of static ones (.lib/.a)" OFF)
get_filename_component(abs "." ABSOLUTE)
set(GKLIB_PATH ${abs})
......@@ -7,7 +9,15 @@ unset(abs)
include(GKlibSystem.cmake)
include_directories(".")
add_library(GKlib STATIC ${GKlib_sources})
if(MSVC)
include_directories("win32")
file(GLOB win32_sources RELATIVE "win32" "*.c")
else(MSVC)
set(win32_sources, "")
endif(MSVC)
add_library(GKlib ${GKlib_sources} ${win32_sources})
if(UNIX)
target_link_libraries(GKlib m)
endif(UNIX)
......@@ -16,6 +26,6 @@ include_directories("test")
add_subdirectory("test")
install(TARGETS GKlib
ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib)
install(FILES ${GKlib_includes} DESTINATION include)
ARCHIVE DESTINATION lib/${LINSTALL_PATH}
LIBRARY DESTINATION lib/${LINSTALL_PATH})
install(FILES ${GKlib_includes} DESTINATION include/${HINSTALL_PATH})
3rdParty/metis/metis-5.1.0/GKlib/GKlib.h → 3rdParty/metis/metis-5.1.1/GKlib/GKlib.h
+ 2
− 1
View file @ 6909eab0
......@@ -3,7 +3,7 @@
*
* George's library of most frequently used routines
*
* $Id: GKlib.h 13005 2012-10-23 22:34:36Z karypis $
* $Id: GKlib.h 14866 2013-08-03 16:40:04Z karypis $
*
*/
......@@ -30,6 +30,7 @@
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <memory.h>
#include <errno.h>
#include <ctype.h>
#include <math.h>
......
3rdParty/metis/metis-5.1.0/GKlib/GKlibSystem.cmake → 3rdParty/metis/metis-5.1.1/GKlib/GKlibSystem.cmake
+ 20
− 12
View file @ 6909eab0
......@@ -3,15 +3,16 @@ include(CheckFunctionExists)
include(CheckIncludeFile)
# Setup options.
#option(GDB "enable use of GDB" OFF)
#option(ASSERT "turn asserts on" OFF)
#option(ASSERT2 "additional assertions" OFF)
#option(DEBUG "add debugging support" OFF)
#option(GPROF "add gprof support" OFF)
#option(OPENMP "enable OpenMP support" OFF)
#option(PCRE "enable PCRE support" OFF)
#option(GKREGEX "enable GKREGEX support" OFF)
#option(GKRAND "enable GKRAND support" OFF)
option(GDB "enable use of GDB" OFF)
option(ASSERT "turn asserts on" OFF)
option(ASSERT2 "additional assertions" OFF)
option(DEBUG "add debugging support" OFF)
option(GPROF "add gprof support" OFF)
option(OPENMP "enable OpenMP support" OFF)
option(PCRE "enable PCRE support" OFF)
option(GKREGEX "enable GKREGEX support" OFF)
option(GKRAND "enable GKRAND support" OFF)
# Add compiler flags.
if(MSVC)
......@@ -20,7 +21,6 @@ if(MSVC)
elseif(MINGW)
set(GKlib_COPTS "-DUSE_GKREGEX")
else()
set(GKlib_COPTS "-O3")
set(GKlib_COPTIONS "-DLINUX -D_FILE_OFFSET_BITS=64")
endif(MSVC)
if(CYGWIN)
......@@ -29,16 +29,22 @@ endif(CYGWIN)
if(CMAKE_COMPILER_IS_GNUCC)
# GCC opts.
set(GKlib_COPTIONS "${GKlib_COPTIONS} -std=c99 -fno-strict-aliasing")
set(GKlib_COPTIONS "${GKlib_COPTIONS} -march=native")
if(NOT MINGW)
set(GKlib_COPTIONS "${GKlib_COPTIONS} -fPIC")
endif(NOT MINGW)
# GCC warnings.
set(GKlib_COPTIONS "${GKlib_COPTIONS} -Wall -pedantic -Wno-unused-but-set-variable -Wno-unused-variable -Wno-unknown-pragmas")
set(GKlib_COPTIONS "${GKlib_COPTIONS} -Werror -Wall -pedantic -Wno-unused-function -Wno-unused-but-set-variable -Wno-unused-variable -Wno-unknown-pragmas -Wno-unused-label")
elseif(${CMAKE_C_COMPILER_ID} MATCHES "Sun")
# Sun insists on -xc99.
set(GKlib_COPTIONS "${GKlib_COPTIONS} -xc99")
endif(CMAKE_COMPILER_IS_GNUCC)
# Intel compiler
if(${CMAKE_C_COMPILER_ID} MATCHES "Intel")
set(GKlib_COPTIONS "${GKlib_COPTIONS} -xHost -std=c99")
endif()
# Find OpenMP if it is requested.
if(OPENMP)
include(FindOpenMP)
......@@ -54,6 +60,8 @@ endif(OPENMP)
if(GDB)
set(GKlib_COPTS "${GKlib_COPTS} -g")
set(GKlib_COPTIONS "${GKlib_COPTIONS} -Werror")
else()
set(GKlib_COPTS "-O3")
endif(GDB)
......@@ -104,7 +112,7 @@ endif(HAVE_GETLINE)
# Custom check for TLS.
if(MSVC)
set(GKlib_COPTIONS "${GKlib_COPTIONS} -D__thread=__declspec(thread)")
else()
# This if checks if that value is cached or not.
if("${HAVE_THREADLOCALSTORAGE}" MATCHES "^${HAVE_THREADLOCALSTORAGE}$")
try_compile(HAVE_THREADLOCALSTORAGE
......
3rdParty/metis/metis-5.1.1/GKlib/LICENSE.txt 0 → 100644
+ 18
− 0
View file @ 6909eab0
Copyright & License Notice
---------------------------
Copyright 1995-2018, Regents of the University of Minnesota
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied. See the License for the specific language governing
permissions and limitations under the License.
3rdParty/metis/metis-5.1.0/GKlib/Makefile → 3rdParty/metis/metis-5.1.1/GKlib/Makefile
+ 6
− 2
View file @ 6909eab0
# Configuration options.
cc = gcc
prefix = ~/local
openmp = not-set
gdb = not-set
assert = not-set
assert2 = not-set
debug = not-set
gprof = not-set
openmp = not-set
prefix = not-set
pcre = not-set
gkregex = not-set
gkrand = not-set
......@@ -49,6 +50,9 @@ endif
ifneq ($(prefix), not-set)
CONFIG_FLAGS += -DCMAKE_INSTALL_PREFIX=$(prefix)
endif
ifneq ($(cc), not-set)
CONFIG_FLAGS += -DCMAKE_C_COMPILER=$(cc)
endif
define run-config
mkdir -p $(BUILDDIR)
......
3rdParty/metis/metis-5.1.1/GKlib/README.md 0 → 100644
+ 54
− 0
View file @ 6909eab0
# GKlib
A library of various helper routines and frameworks used by many of the lab's software
## Build requirements
- CMake 2.8, found at http://www.cmake.org/, as well as GNU make.
Assuming that the above are available, two commands should suffice to
build the software:
```
make config
make
```
## Configuring the build
It is primarily configured by passing options to make config. For example:
```
make config cc=icc
```
would configure it to be built using icc.
Configuration options are:
```
cc=[compiler] - The C compiler to use [default: gcc]
prefix=[PATH] - Set the installation prefix [default: ~/local]
openmp=set - To build a version with OpenMP support
```
## Building and installing
To build and install, run the following
```
make
make install
```
By default, the library file, header file, and binaries will be installed in
```
~/local/lib
~/local/include
~/local/bin
```
## Other make commands
make uninstall
Removes all files installed by 'make install'.
make clean
Removes all object files but retains the configuration options.
make distclean
Performs clean and completely removes the build directory.
3rdParty/metis/metis-5.1.0/GKlib/blas.c → 3rdParty/metis/metis-5.1.1/GKlib/blas.c
+ 2
− 1
View file @ 6909eab0
......@@ -12,7 +12,7 @@ which is used for code generation.
\date Started 9/28/95
\author George
\version\verbatim $Id: blas.c 11848 2012-04-20 13:47:37Z karypis $ \endverbatim
\version\verbatim $Id: blas.c 14330 2013-05-18 12:15:15Z karypis $ \endverbatim
*/
#include <GKlib.h>
......@@ -27,6 +27,7 @@ GK_MKBLAS(gk_i, int, int)
GK_MKBLAS(gk_i32, int32_t, int32_t)
GK_MKBLAS(gk_i64, int64_t, int64_t)
GK_MKBLAS(gk_z, ssize_t, ssize_t)
GK_MKBLAS(gk_zu, size_t, size_t)
GK_MKBLAS(gk_f, float, float)
GK_MKBLAS(gk_d, double, double)
GK_MKBLAS(gk_idx, gk_idx_t, gk_idx_t)
......
3rdParty/metis/metis-5.1.1/GKlib/cache.c 0 → 100644
+ 126
− 0
View file @ 6909eab0
/*!
\file
\brief Functions dealing with simulating cache behavior for performance
modeling and analysis;
\date Started 4/13/18
\author George
\author Copyright 1997-2011, Regents of the University of Minnesota
\version $Id: cache.c 21991 2018-04-16 03:08:12Z karypis $
*/
#include <GKlib.h>
/*************************************************************************/
/*! This function creates a cache
*/
/*************************************************************************/
gk_cache_t *gk_cacheCreate(uint32_t nway, uint32_t lnbits, size_t cnbits)
{
gk_cache_t *cache;
cache = (gk_cache_t *)gk_malloc(sizeof(gk_cache_t), "gk_cacheCreate: cache");
memset(cache, 0, sizeof(gk_cache_t));
cache->nway = nway;
cache->lnbits = lnbits;
cache->cnbits = cnbits;
cache->csize = 1<<cnbits;
cache->cmask = cache->csize-1;
cache->latimes = gk_ui64smalloc(cache->csize*nway, 0, "gk_cacheCreate: latimes");
cache->clines = gk_zusmalloc(cache->csize*nway, 0, "gk_cacheCreate: clines");
return cache;
}
/*************************************************************************/
/*! This function resets a cache
*/
/*************************************************************************/
void gk_cacheReset(gk_cache_t *cache)
{
cache->nhits = 0;
cache->nmisses = 0;
gk_ui64set(cache->csize*cache->nway, 0, cache->latimes);
gk_zuset(cache->csize*cache->nway, 0, cache->clines);
return;
}
/*************************************************************************/
/*! This function destroys a cache.
*/
/*************************************************************************/
void gk_cacheDestroy(gk_cache_t **r_cache)
{
gk_cache_t *cache = *r_cache;
if (cache == NULL)
return;
gk_free((void **)&cache->clines, &cache->latimes, &cache, LTERM);
*r_cache = NULL;
}
/*************************************************************************/
/*! This function simulates a load(ptr) operation.
*/
/*************************************************************************/
int gk_cacheLoad(gk_cache_t *cache, size_t addr)
{
uint32_t i, nway=cache->nway;
size_t lru=0;
//printf("%16"PRIx64" ", (uint64_t)addr);
addr = addr>>(cache->lnbits);
//printf("%16"PRIx64" %16"PRIx64" %16"PRIx64" ", (uint64_t)addr, (uint64_t)addr&(cache->cmask), (uint64_t)cache->cmask);
size_t *clines = cache->clines + (addr&(cache->cmask));
uint64_t *latimes = cache->latimes + (addr&(cache->cmask));
cache->clock++;
for (i=0; i<nway; i++) { /* look for hits */
if (clines[i] == addr) {
cache->nhits++;
latimes[i] = cache->clock;
goto DONE;
}
}
for (i=0; i<nway; i++) { /* look for empty spots or the lru spot */
if (clines[i] == 0) {
lru = i;
break;
}
else if (latimes[i] < latimes[lru]) {
lru = i;
}
}
/* initial fill or replace */
cache->nmisses++;
clines[lru] = addr;
latimes[lru] = cache->clock;
DONE:
//printf(" %"PRIu64" %"PRIu64"\n", cache->nhits, cache->clock);
return 1;
}
/*************************************************************************/
/*! This function returns the cache's hitrate
*/
/*************************************************************************/
double gk_cacheGetHitRate(gk_cache_t *cache)
{
return ((double)cache->nhits)/((double)(cache->clock+1));
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment