oct_f.c

Go to the documentation of this file.

/*
 Copyright (C) 2002 M. Marques, A. Castro, A. Rubio, G. Bertsch
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 02110-1301, USA.
 
*/
 
#include <config.h>
 
#include <assert.h>
#include <ctype.h>
#include <libgen.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#if __has_include(<unistd.h>)
#include <unistd.h>
#endif
 
#include <fortran_types.h>
 
#ifdef _POSIX_VERSION
#include <dirent.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#endif
 
/* needed for getting executable path on Mac */
#if defined(__APPLE__) && defined(__MACH__)
#include <mach-o/dyld.h>
#endif
 
#if (defined(__APPLE__) && defined(__MACH__)) || defined(__FreeBSD__)
#include <sys/sysctl.h>
#endif
 
/* *********************** interface functions ********************** */
 
void oct_mkdir(char * name_c) {
  struct stat buf;
 
  if (!*name_c)
    return;
 
  if (stat(name_c, &buf) == 0) {
    return;
  }
 
#ifndef _WIN32
  mkdir(name_c, 0775);
#else
  mkdir(name_c);
#endif
 
}
 
void oct_stat(fint *ierr, char * name_c,
                           char * mod_time_c) {
  struct stat statbuf;
  time_t mtime;
  struct tm *timeinfo;
 
  *ierr = stat(name_c, &statbuf);
 
  if (*ierr == 0) {
    mtime = statbuf.st_mtime; /* last modification time */
    timeinfo = localtime(&mtime);
    mod_time_c = asctime(timeinfo);
  } else {
    perror(name_c); /* what is the problem? */
    mod_time_c = malloc(sizeof(char));
    mod_time_c[0] = '\0';
  }
 
  if (*ierr != 0) {
    printf("ierr = %i\n", *ierr);
  }
  /* otherwise, do not do this since 'mod_time_c' points at static data of
   * asctime */
}
 
int oct_dir_exists(char * name_c) {
  int ierr;
  struct stat statbuf;
 
  ierr = stat(name_c, &statbuf);
 
  if (ierr == 0) {
    return S_ISDIR(statbuf.st_mode);
  } else {
    return 0;
  }
}
 
void oct_rm(char * name_c) {
  unlink(name_c);
}
 
void oct_getcwd(char * name) {
  getcwd(name, 256);
}
 
void oct_realpath(char * fn, char * rn) {
  char* tmp = NULL;
  tmp = realpath(fn, NULL);
  strcpy(rn, tmp);
  free(tmp);
}
 
void oct_dirname(char * fn, char * dn) {
  strcpy(dn, dirname(fn));
}
 
void oct_basename(char * fn, char * bn) {
  strcpy(bn, basename(fn));
}
 
void oct_getenv(char * name_c, char * var_c) {
  char* tmp = NULL;
  tmp = getenv(name_c);
  if (tmp != NULL) {
    strcpy(var_c, tmp);
  }
  else {
    strcpy(var_c, "");
  }
}
 
/* this function gets a string of the form '1-12, 34' and fills
         array l with the 1 if the number is in the list, or 0 otherwise */
void oct_wfs_list(char * str_c, fint l[16384]) {
  int i, i1, i2;
  char c[20], *c1, *s;
 
  s = str_c;
 
  /* clear list */
  for (i = 0; i < 16384; i++)
    l[i] = 0;
 
  while (*s) {
    /* get integer */
    for (c1 = c; isdigit(*s) || isspace(*s); s++)
      if (isdigit(*s))
        *c1++ = *s;
    *c1 = '\0';
    i1 = atoi(c) - 1;
 
    if (*s == '-') { /* range */
      s++;
      for (c1 = c; isdigit(*s) || isspace(*s); s++)
        if (isdigit(*s))
          *c1++ = *s;
      *c1 = '\0';
      i2 = atoi(c) - 1;
    } else /* single value */
      i2 = i1;
 
    for (i = i1; i <= i2; i++)
      if (i >= 0 && i < 16384)
        l[i] = 1;
 
    if (*s)
      s++;
  }
}
 
/* ------------------------------ from varia.c -------------------------------
 */
#include "varia.h"
 
void FC_FUNC_(oct_progress_bar, OCT_PROGRESS_BAR)(fint *a, fint *max) {
  if (*max == 0)
    return; /* Skip the bar if the length is 0 */
  progress_bar(*a, *max);
}
 
/* ------------------------------ some stuff  --------------------------------
 */
void FC_FUNC_(oct_gettimeofday, OCT_GETTIMEOFDAY)(fint *sec, fint *usec) {
#ifdef _POSIX_VERSION
  struct timeval tv;
 
  gettimeofday(&tv, NULL);
 
  /* The typecast below should use long. However, this causes incompatibilities
     with Fortran integers.
     Using int will cause wrong results when tv.tv_sec exceeds
     INT_MAX=2147483647 */
  *sec = (int)tv.tv_sec;
  *usec = (int)tv.tv_usec;
/*
  char str[sizeof("HH:MM:SS")];
  time_t local;
  local = tv.tv_sec;
  strftime(str, sizeof(str), "%T", localtime(&local));
  printf("%s.%06ld \n", str, (long) tv.tv_usec);
  printf("%ld.%06ld \n", (long) tv.tv_sec, (long) tv.tv_usec);
*/
#else
  *sec = 0;
  *usec = 0;
#endif
}
 
double FC_FUNC_(oct_clock, OCT_CLOCK)() {
#ifdef _POSIX_VERSION
  int sec, usec;
  FC_FUNC_(oct_gettimeofday, OCT_GETTIMEOFDAY)(&sec, &usec);
  return sec + 1.0e-6 * usec;
#else
  return (double)clock() / CLOCKS_PER_SEC;
#endif
}
 
void FC_FUNC_(oct_nanosleep, OCT_NANOSLEEP)(fint *sec, fint *nsec) {
#ifdef _POSIX_VERSION
  /* Datatypes should be long instead of int (see comment in gettimeofday) */
  struct timespec req;
  req.tv_sec = (time_t)*sec;
  req.tv_nsec = (long)*nsec;
  nanosleep(&req, NULL);
#endif
}
 
void oct_sysname(char * name_c) {
 
  char* tmp = NULL;
  sysname(&tmp);
  strcpy(name_c, tmp);
  free(tmp);
}
 
int oct_number_of_lines(char * name_c) {
 
  FILE *pf;
  int c, i;
 
  pf = fopen(name_c, "r");
 
  if (pf != NULL) {
    i = 0;
    while ((c = getc(pf)) != EOF) {
      if (c == '\n')
        i++;
    }
    fclose(pf);
    return i;
  } else {
    return -1;
  }
}
 
/* Given a string in C, it breaks it line by line and returns each
   as a Fortran string. Returns 0 if string does not have more lines.
*/
void FC_FUNC_(oct_break_c_string,
              OCT_BREAK_C_STRING)(char **str, char **s,
                                  char * line_f) {
  char *c, line[256]; /* hopefully no line is longer than 256 characters ;) */
 
  if (*s == NULL)
    *s = *str;
 
  if (*s == NULL || **s == '\0') {
    *s = (char *)(0);
    return;
  }
 
  for (c = line; **s != '\0' && **s != '\n'; (*s)++, c++)
    *c = **s;
  *c = '\0';
  if (**s == '\n')
    (*s)++;
 
  strcpy(line_f, line);
}
 
/*
 
This function searches in directory given by dirname all files that have the
following name:
 
*_<real_number>_<integer>*
 
It returns the value of <real_number> found that is closest to freq (or
abs(freq)) and for which the value of <integer> matches with the tag argument.
 
The value found is returned in the freq argument.
 
ierr results:
0 : value found
1 : no matching file found
2 : cannot open the directory or function not available
 
*/
 
void oct_search_file_lr(double *freq, const fint *tag, fint *ierr,
                                  char * name_c) {
#ifdef _POSIX_VERSION
 
  DIR *dir;
  struct dirent *ent;
  char *num_start, *num_end;
  double read_value, min;
  int found_something, read_tag;
 
  dir = opendir(name_c);
 
  if (dir == NULL) {
    *ierr = 2;
    return;
  }
 
  ent = NULL;
  found_something = 0;
 
  while (1) {
    ent = readdir(dir);
    if (ent == NULL)
      break;
 
    num_start = strchr(ent->d_name, '_');
 
    if (num_start != NULL) {
      num_start++; /* now this points to the beginning of the number */
 
      /* take the numerical value from the string */
      read_value = strtod(num_start, &num_end);
 
      if (num_end == num_start)
        continue; /* no number found */
 
      /* check that we have the correct tag */
      if (num_end[0] == '_') {
 
        num_start = num_end + 1;
        read_tag = (int)strtol(num_start, &num_end, 10);
        if (num_end == num_start)
          continue; /* no tag found */
        if (read_tag != *tag)
          continue; /* tag does not match */
 
      } else
        continue;
 
      /* if this is the first number we found */
      if (!found_something) {
        min = read_value;
        found_something = 1;
      } else if (fabs(fabs(min) - fabs(*freq)) >
                 fabs(fabs(read_value) - fabs(*freq))) {
        /* if the value is closer than previous */
        min = read_value;
      }
    }
  }
 
  closedir(dir);
 
  if (found_something) {
    *ierr = 0;
    *freq = min;
  } else {
    *ierr = 1;
  }
 
#else
#warning directory search not compiled
  fprintf(stderr, "Warning: Directory search not available since certain C "
                  "functions are not available.\n");
  *ierr = 2;
#endif
}
 
#if !(defined(__APPLE__) && defined(__MACH__))
/* Reads one attribute of a cache of the first CPU from sysfs; returns 1 on success */
static int read_cache_attribute(int index, const char *name, char *text) {
  char path[128];
  snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu0/cache/index%d/%s", index, name);
  FILE *file = fopen(path, "r");
  if (file == NULL)
    return 0;
  int nread = fscanf(file, "%31s", text);
  fclose(file);
  return nread == 1;
}
#endif
 
/* Size and line size in bytes of the data cache of a level of the first CPU, 0 if unknown */
void oct_cache_info(int level, int *size, int *line_size) {
  *size = 0;
  *line_size = 0;
#if defined(__APPLE__) && defined(__MACH__)
  long long value = 0;
  size_t length = sizeof(value);
  if (sysctlbyname(level == 1 ? "hw.perflevel0.l1dcachesize" : "hw.perflevel0.l2cachesize",
                   &value, &length, NULL, 0) != 0 || value <= 0) {
    value = 0;
    length = sizeof(value);
    sysctlbyname(level == 1 ? "hw.l1dcachesize" : "hw.l2cachesize", &value, &length, NULL, 0);
  }
  *size = (int)value;
  value = 0;
  length = sizeof(value);
  sysctlbyname("hw.cachelinesize", &value, &length, NULL, 0);
  *line_size = (int)value;
#else
  /* Linux, any architecture; without sysfs (e.g. FreeBSD) the defaults stay */
  char text[32];
  for (int index = 0; read_cache_attribute(index, "level", text); index++) {
    if (atoi(text) != level)
      continue;
    if (!read_cache_attribute(index, "type", text) || strcmp(text, "Instruction") == 0)
      continue;
    if (read_cache_attribute(index, "size", text)) {
      char unit = 'B';
      int value = 0;
      if (sscanf(text, "%d%c", &value, &unit) >= 1)
        *size = value * (unit == 'K' ? 1024 : unit == 'M' ? 1024 * 1024 : 1);
    }
    if (read_cache_attribute(index, "coherency_line_size", text))
      *line_size = atoi(text);
    return;
  }
#endif
}
 
void *FC_FUNC_(oct_get_memory_usage, OCT_GET_MEMORY_USAGE)() {
#ifdef _POSIX_VERSION
  static size_t pagesize = 0;
  FILE *f;
  int pid;
  unsigned long mem;
  char s[256];
 
  if (pagesize == 0)
    pagesize = sysconf(_SC_PAGESIZE);
 
  pid = getpid();
  sprintf(s, "%s%d%s", "/proc/", pid, "/statm");
  if ((f = fopen(s, "r")) == (FILE *)NULL)
    return (void *)(-1);
  fscanf(f, "%lu", &mem);
  fclose(f);
 
  return (void *)(mem * pagesize);
#else
  return 0;
#endif
}
 
/* Get the path to the current executable. As there is no portable solution,
 * we need a different implementation for Linux and Mac (and possible other OSs) */
void oct_executable_path(char * path) {
  char *tmp = NULL;
#if defined(__APPLE__) && defined(__MACH__)
  char *buf = NULL;
  uint32_t bufsize = 0;
  int ret = 0;
  ret = _NSGetExecutablePath(buf, &bufsize);
  assert(ret == -1);
  buf = (char *)malloc(bufsize);
  assert(buf != NULL);
  ret = _NSGetExecutablePath(buf, &bufsize);
  assert(ret == 0);
  tmp = realpath(buf, NULL);
  free(buf);
#elif defined(linux) || defined(__linux)
  tmp = realpath("/proc/self/exe", NULL);
#elif defined(__NETBSD__) || defined(__NetBSD__)
  tmp = realpath("/proc/curproc/exe", NULL);
#elif defined(__DragonFly__)
  tmp = realpath("/proc/curproc/file", NULL);
#elif defined(__FreeBSD__)
  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
  size_t len = 0;
  int ret = 0;
  ret = sysctl(mib, 4, NULL, &len, NULL, 0);
  assert(ret == 0);
  tmp = malloc(len);
  assert(tmp != NULL);
  ret = sysctl(mib, 4, tmp, &len, NULL, 0);
  assert(ret == 0);
#else
  /* if OS is not recognized, return empty string - in the calling code, this is then ignored */
  tmp = (char *)malloc(1);
  assert(tmp != NULL);
  tmp[0] = '\0';
#endif
  if (tmp == NULL) {
    fprintf(stderr, "%s:%d: in %s: Something went wrong\n", __FILE__, __LINE__, __func__);
    tmp = (char *)malloc(1);
    assert(tmp != NULL);
    tmp[0] = '\0';
  }
  strcpy(path, tmp);
  free(tmp);
  return;
}