config.c

基于Blas CLapck的.用过的人知道是干啥的

#include "atlconf.h"

int GetStrProbe(int verb, char *targarg, char *prb, char *id, char *str)
/*
 * Performs probe where output is string delimited by '', leaving string
 * in str.
 * RETURNS: 0 on success, non-zero on error
 */
{
   char *sp;
   char ln[2048], ln2[2048];
   int ierr=0, i;

   ln[0] = ln2[0] = '\0';
   sprintf(ln, "make IRun_%s args=\"-v %d %s\" | fgrep '%s='",
           prb, verb, targarg, id);
   if (verb > 1)
      printf("cmnd=%s\n", ln);
   ierr = CmndOneLine(NULL, ln, ln2);
   if (!ierr)
   {
      sprintf(ln, "%s='", id);
      sp = strstr(ln2, ln);
      if (sp)
      {
         for (sp += strlen(ln); *sp && *sp != '\''; sp++)
            *str++ = *sp;
         if (!(*sp)) ierr = -2;
         *str = '\0';
      }
      else ierr = -4;
   }
   return(ierr);
}

int GetIntProbe(int verb, char *targarg, char *prb, char *id, int N)
{
   char ln[2048], ln2[2048];
   int iret=0, ierr;

   ln[0] = ln2[0] = '\0';
   sprintf(ln, "make IRun_%s args=\"-v %d %s\" | fgrep '%s='",
           prb, verb, targarg, id);
   if (verb > 1)
      printf("cmnd=%s\n", ln);
   ierr = CmndOneLine(NULL, ln, ln2);
   if (!ierr)
      iret = GetLastInt(ln2);
   if (N)
   {
      if (iret > N || iret < 1)
      {
         printf("\nBad %s value=%d, ierr=%d, ln2='%s'\n", id, iret, ierr, ln2);
         iret = 0;
      }
   }
   return(iret);
}

int GetIntProbeSure(int verb, char *targarg, char *prb, char *id,
                    int *sure)
{
   char ln[2048], ln2[2048];
   int iret=0, ierr;

   ln[0] = ln2[0] = '\0';
   sprintf(ln, "make IRun_%s args=\"-v %d %s\" | fgrep '%s='",
           prb, verb, targarg, id);
   if (verb > 1)
      printf("cmnd=%s\n", ln);
   ierr = CmndOneLine(NULL, ln, ln2);
   if (!ierr)
   {
      iret = GetFirstInt(ln2);
      *sure = GetLastInt(ln2);
   }
   return(iret);
}

void TransCompsToFlags(char **comps, char *flags)
{
   int i, j;
/*
 * WARNING: if you change the order of the ICC_, etc, must change
 *          compnames!
 */
   char *compnames[7] = {"ic", "sm", "dm", "sk",  "dk", "xc", "if"};

   *flags = '\0';
/*
 * Pass any override compilers/flags and appends to probe
 */
   for (j=i=0; i < NCOMP; i++)
   {
      if (comps[i])
         j += sprintf(flags+j, "-C %s '%s' ", compnames[i], comps[i]);
      if (comps[NCOMP+i])
         j += sprintf(flags+j, "-F %s '%s' ", compnames[i], comps[NCOMP+i]);
      if (comps[2*NCOMP+i])
         j += sprintf(flags+j, "-Fa %s '%s' ", compnames[i], comps[2*NCOMP+i]);
   }
}

char *ProbeComp(int verb, char *targarg, enum OSTYPE OS, enum MACHTYPE arch,
                 char **comps, int nof77, int nocygwin, int ptrbits)
/*
 * RETURNS: f2c define string
 */
{
   char ln[4096], flags[2048], comp[512];
   int f2cname, f2cint, f2cstr;
   char *f2cdefs;
   int i, if77=0;
   FILE *fpin;

   TransCompsToFlags(comps, flags);
   i = sprintf(ln,
   "make IRun_comp args=\"-v %d -o atlconf.txt -O %d -A %d -Si nof77 %d %s %s",
               verb, OS, arch, nof77, targarg, flags);
   if (ptrbits == 64 || ptrbits == 32)
      i += sprintf(ln+i, " -b %d", ptrbits);
   sprintf(ln+i, "\"");
   if (verb > 1)
      fprintf(stderr, "cmnd='%s'\n", ln);
   assert(!system(ln));
   fpin = fopen("atlconf.txt", "r");
   assert(fpin);
   while (fgets(ln, 4096, fpin))
   {
      if (ln[0] != '#')
      {
         if (isdigit(ln[0]))
         {
            assert(sscanf(ln, "%d '%[^']' '%[^']", &i, comp, flags) == 3);
            assert(i >= 0 && i < NCOMP);
            comps[i] = NewStringCopy(comp);
            comps[NCOMP+i] = NewStringCopy(flags);
         }
         else
         {
            for (i=0; ln[i] && ln[i] != '('; i++);
            assert(ln[i] = '(');
            assert(sscanf(ln+i+1, "%d,%d,%d", &f2cname, &f2cint, &f2cstr) == 3);
            if77 = 1;
         }
      }
   }
   fclose(fpin);
/*
 * For windows only, all non-XCC gnu compilers get -mnocygwin flag if user has
 * asked for it
 */
   if (nocygwin && OSIsWin(OS))
   {
      for (i=0; i < NCOMP; i++)
      {
         if (i != XCC_)
         {
            if (CompIsGcc(comps[i]))
               comps[i+NCOMP] = NewAppendedString(comps[i+NCOMP],"-mno-cygwin");
         }
      }
   }
/*
 * Only f77 and xcc allowed to be NULL
 */
   for (i=0; i < NCOMP; i++)
   {
      if (comps[i] == NULL)
      {
         if (i == XCC_)
         {
            comps[XCC_] = NewStringCopy(comps[ICC_]);
            comps[NCOMP+XCC_] = NewStringCopy(comps[ICC_+NCOMP]);
         }
         else assert(i == F77_);
      }
      if (comps[i+NCOMP] == NULL)
      {
         if (i == XCC_)
            comps[XCC_+NCOMP] = NewStringCopy(comps[ICC_+NCOMP]);
         else assert(i == F77_);
      }
   }
/*
 * Echo compiler info to screen if user has asked for verbose output
 */
   if (verb)
   {
      fprintf(stdout, "Selected compilers:\n");
      for (i=0; i < NCOMP; i++)
      {
         fprintf(stdout, "%s = '%s' '%s'\n", COMPNAME[i],
                 comps[i] ? comps[i]:"none",
                 comps[NCOMP+i]?comps[NCOMP+i]:"none");
      }
      if (if77)
      {
         fprintf(stdout, "\nF77 calling C interface information:\n");
         fprintf(stdout, "   Name decoration = %s\n", f2c_namestr[f2cname]);
         fprintf(stdout, "   Integer style   = %s\n", f2c_intstr[f2cint]);
         fprintf(stdout, "   String style    = %s\n", f2c_strstr[f2cstr]);
      }
      else
         fprintf(stderr, "F77/C interface not defined!");
   }
   if (!if77)
      f2cdefs = NULL;
   else
   {
      sprintf(ln, "-D%s -D%s -DString%s",
              f2c_namestr[f2cname], f2c_intstr[f2cint], f2c_strstr[f2cstr]);
      f2cdefs = malloc(sizeof(char)*(strlen(ln)+1));
      assert(f2cdefs);
      strcpy(f2cdefs, ln);
   }
   return(f2cdefs);
}

int PathLength(char *str)
/*
 * Given string, finds end unix path, allowing \ to mean sticky space, stops at
 * first non-sticky pass.  Skips any leading spaces.
 * RETURNS: index of first non-sticky space
 * NOTE: Assumes str[-1] valid
 */
{
   int i;
   for (i=0; isspace(str[i]); i++);  /* skip leading spaces */
   for (; str[i]; i++)
      if (str[i] == ' ' && str[i-1] != '\\') break;
   return(i);
}

char *ProbeF77LIB(int verb, char *targarg, enum OSTYPE OS,
                  enum MACHTYPE arch, char **comps, char *f2cdefs, int nof77)
/*
 * Tries to find the directory that needs to be included to link in f77
 * routines
 */
{
   char cmnd[1024], res[2048];
   char *f77lib, *F77LIBdir, *sp;
   int i;
   char ch;

   if (nof77 || !f2cdefs) return(NULL);
   if  (strstr(comps[F77_], "g77")) f77lib = "g2c";
   else if (strstr(comps[F77_], "gfortran")) f77lib = "gfortran";
   else
   {
      if (verb > 1)
         fprintf(stderr, "Unknown F77 compiler, leaving F77LIBS blank!\n");
      return(NULL);
   }
   sprintf(cmnd,  "make IRunFlib F77='%s' F77FLAGS='%s'",
           comps[F77_], comps[NCOMP+F77_]);
   if (verb > 1)
      fprintf(stderr, "LIBDIR cmnd = %s\n", cmnd);
   CmndOneLine(NULL, cmnd, res);
   if (verb > 1)
      fprintf(stderr, "LIBDIR res = %s\n", res);
/*
 * Find which -L leads us to f77lib
 */
   sp = res;
   while (sp = strstr(sp, "-L"))
   {
      sp += 2;
      i = PathLength(sp);
      if (i)
      {
         ch = sp[i];
         sp[i] = '\0';
         sprintf(cmnd, "make IRunTestCFLink F77='%s' F77FLAGS='%s' CC='%s' CCFLAGS='%s -L%s' F77LIB='%s' LIBS='-lm'",
                 comps[F77_], comps[NCOMP+F77_],
                 comps[ICC_], comps[NCOMP+ICC_], sp, f77lib);
         if (verb > 1)
            fprintf(stderr, "cmnd = %s\n", cmnd);
         if (verb > 1)
            fprintf(stderr, "Trying F77 link path of %s ... ", sp);
         if (!system(cmnd))
         {
            if (verb > 1) fprintf(stderr, "SUCCESS!\n");
            F77LIBdir = NewStringCopy(sp-2);
            F77LIBdir = NewAppendedString(F77LIBdir, "-l");
            F77LIBdir = NewAppendedString(F77LIBdir, f77lib);
            if (verb)
               fprintf(stderr, "F77LIB = %s\n", F77LIBdir);
            return(F77LIBdir);
         }
         if (verb > 1) fprintf(stderr, "REJECTED!!!!\n");
         sp[i] = ch;
         sp += i;
      }
   }
   if (verb) fprintf(stderr, "F77LIB left blank");
   return(NULL);
}

enum OSTYPE ProbeOS(int verb, char *targarg)
{
   enum OSTYPE iret;

   iret = GetIntProbe(verb, targarg, "OS", "OS", NOS);
   printf("\nOS configured as %s (%d)\n", osnam[iret], iret);
   assert(iret);
   return(iret);
}

enum ASMDIA ProbeAsm(int verb, char *targarg, enum OSTYPE OS)
{
   enum ASMDIA asmd=ASM_None;
   char ln[1024];

   sprintf(ln, "%s -O %d", targarg, OS);
   asmd = GetIntProbe(verb, ln, "asm", "ASM", NASMD);
   printf("\nAssembly configured as %s (%d)\n", ASMNAM[asmd], asmd);
   return(asmd);
}

int ProbeVecs(int verb, char *targarg, enum OSTYPE OS, enum ASMDIA asmb)
{
   int i, iret;
   char ln[1024];

   sprintf(ln, "%s -O %d -s %d", targarg, OS, asmb);
   iret = GetIntProbe(verb, ln, "vec", "VECFLAG", (1<<NISA));
   for (i=0; i < NISA && (iret & (1<<i)) == 0; i++);
   if (i == NISA)
      i = 0;
   printf("\nVector ISA Extension configured as  %s (%d,%d)\n",
          ISAXNAM[i], i, iret);
   return(iret);
}

int ProbeArch(int verb, char *targarg, enum OSTYPE OS, enum ASMDIA asmb)
{
   int i, iret;
   char ln[1024];

   sprintf(ln, "%s -O %d -s %d -a", targarg, OS, asmb);
   iret = GetIntProbe(verb, ln, "arch", "MACHTYPE", NMACH);
   printf("\nArchitecture configured as  %s (%d)\n",
          machnam[iret], iret);
   return(iret);
}

int ProbeMhz(int verb, char *targarg, enum OSTYPE OS, enum ASMDIA asmb)
{
   int i, iret;
   char ln[1024];

   sprintf(ln, "%s -O %d -s %d -m", targarg, OS, asmb);
   iret = GetIntProbe(verb, ln, "arch", "CPU MHZ", 16384);
   printf("\nClock rate configured as %dMhz\n", iret);
   return(iret);
}

int ProbeNcpu(int verb, char *targarg, enum OSTYPE OS, enum ASMDIA asmb)
{
   int i, iret;
   char ln[1024];

   sprintf(ln, "%s -O %d -s %d -n", targarg, OS, asmb);
   iret = GetIntProbe(verb, ln, "arch", "NCPU", 2048);
   printf("\nMaximum number of threads configured as  %d\n", iret);
   return(iret);
}

int ProbePtrbits(int verb, char *targarg, enum OSTYPE OS, enum ASMDIA asmb)
{
   int i, iret;
   char ln[1024];

   sprintf(ln, "%s -O %d -s %d -b", targarg, OS, asmb);
   iret = GetIntProbeSure(verb, ln, "arch", "PTR BITS", &i);
/*
 * If it's not 64-bit, make sure it's not just because of flag setting
 */
   if (iret != 64)
   {
   }
   if (iret != 64)
      iret = 32;
   printf("\nPointer width configured as %d\n", iret);
   return(iret);
}

int ProbeCPUThrottle(int verb, char *targarg, enum OSTYPE OS, enum ASMDIA asmb)
{
   int i, iret;
   char ln[1024];
   sprintf(ln, "%s -O %d -s %d -t", targarg, OS, asmb);
   iret = GetIntProbe(verb, ln, "arch", "CPU THROTTLE", 0);
   if (iret) printf("CPU Throttling apparently enabled!\n");
   else printf("Cannot detect CPU throttling.\n");
   return(iret);
}


void Comps2Flags(char **comps, char *ln)
/*
 * Takes the comps array (1st NCOMP entries are compilers, next NCOMP entries
 * flags for those compilers) and translates them into the corresponding flags
 * for xspew (or indeed this config.c)
 * NOTE: assumes appended flags (2*NCOMP+i) already appended to flags (NCOMP+i)
 */
{
   char *cname[NCOMP] = {"ic", "sm", "dm", "sk", "dk", "xc", "if"};
   int i, j=0;
   ln[0] = '\0';
   for (i=0; i < NCOMP; i++)
   {
      if (comps[i])
         j += sprintf(ln+j, "-C %s '%s' ", cname[i], comps[i]);
      if (comps[NCOMP+i])
         j += sprintf(ln+j, "-F %s '%s' ", cname[i], comps[NCOMP+i]);
   }
}

char *ProbePmake(int verb, enum OSTYPE OS, int ncpu)
/*
 * WARNING: if cross-comp really worked, this would be ncpu of front-end,
 *          not backend!
 */
{
   char args[256], res[1024];
   char *sp;

   sprintf(args, "-O %d -t %d", OS, ncpu);
   if (!GetStrProbe(verb, args, "pmake", "PMAKE", res))
   {
      sp = malloc((strlen(res)+1)*sizeof(char));
      strcpy(sp, res);
   }
   else sp = NULL;
   if (sp) printf("Parallel make command configured as '%s'\n", sp);
   else printf("Parallel make not configured.\n");
   return(sp);
}

void SpewItForth(int verb, enum OSTYPE OS, enum MACHTYPE arch, int mhz,
                 enum ASMDIA asmb, int vecexts, int ptrbits, int ncpu,
                 int l2size, char *srcdir, char *bindir, int bozol1,
                 int archdef, int nof77, char **comps, char *gccflags,
                 char *f2cdefs, char *cdefs, char *pmake, char *flapack,
                 char *smaflags, char *dmaflags, char *f77libs)
/*
 * Calls xspew with correct arguments to build required Make.inc
 */
{
   char ln[4096], compsflags[1024], archflags[1024];
   int i;
   assert(CmndResults(NULL, "make xspew"));
/*
 * Translate compiler/flag array to xspew flags
 */
   Comps2Flags(comps, compsflags);
   i = sprintf(ln, "./xspew -v %d -O %d -A %d -m %d -s %d -V %d -b %d -t %d -f %d -d s '%s' -d b '%s' -D c '%s' -D f '%s' %s -Si archdef %d -Si bozol1 %d -Si nof77 %d -o Make.inc",
               verb, OS, arch, mhz, asmb, vecexts, ptrbits, ncpu, l2size,
               srcdir, bindir, cdefs ? cdefs:"", f2cdefs? f2cdefs : "",
               compsflags, archdef, bozol1, nof77);
   if (pmake)
      i += sprintf(ln+i, " -Ss pmake '%s'", pmake);
   if (flapack)
      i += sprintf(ln+i, " -Ss flapack '%s'", flapack);
   if (smaflags)