Changeset 33646

Timestamp:

Apr 1, 2012, 2:15:36 PM (14 years ago)

Author:

eugene

Message:

move myAssert, myAbort, OHANA_ASSERT into libohana; add features to parse time and ints in space and csv lines (used by opihi/read functions); add abspath function; move rconnect into libohana

Location:

trunk/Ohana/src/libohana

Files:

• Makefile (modified) (1 diff)
• include/ohana.h (modified) (5 diffs)
• include/ohana_allocate.h (modified) (1 diff)
• src/findexec.c (modified) (1 diff)
• src/memstr.c (copied) (copied from branches/eam_branches/ipp-20111122/Ohana/src/libohana/src/memstr.c )
• src/rconnect.c (copied) (copied from branches/eam_branches/ipp-20111122/Ohana/src/libohana/src/rconnect.c )
• src/string.c (modified) (2 diffs)
• test/memspeed.c (copied) (copied from branches/eam_branches/ipp-20111122/Ohana/src/libohana/test/memspeed.c )

trunk/Ohana/src/libohana/Makefile

@@ -38 +38 @@
 $(SRC)/Fread.$(ARCH).o           \
 $(SRC)/IOBufferOps.$(ARCH).o     \
+$(SRC)/memstr.$(ARCH).o  \
+$(SRC)/rconnect.$(ARCH).o        \
 $(SRC)/CommOps.$(ARCH).o         \
 $(SRC)/isolate_elements.$(ARCH).o        \

trunk/Ohana/src/libohana/include/ohana.h

@@ -215 +215 @@
 */
 # define OHANA_WHITESPACE(c)(((c) == 0x09) || ((c) == 0x0a) || ((c) == 0x0b) || ((c) == 0x0b) || ((c) == 0x0c) || ((c) == 0x0d) || ((c) == 0x20))
+# define OHANA_ASSERT(LOGIC,...) { if (!(LOGIC)) { fprintf (stderr, __VA_ARGS__); abort(); } }
+# define myAssert(LOGIC,...) { if (!(LOGIC)) { fprintf (stderr, __VA_ARGS__); abort(); } }
+# define myAbort(MSG) { fprintf (stderr, "%s\n", MSG); abort(); }
 
 // sorting is now defined as a macro call
@@ -236 +239 @@
 char   *strncreate             PROTO((char *string, int n));
 int     scan_line              PROTO((FILE *f, char *line)); 
+int     scan_line_maxlen       PROTO((FILE *f, char *line, int maxlen)); 
 int     dparse                 PROTO((double *X, int NX, char *line));
 int     dparse_csv             PROTO((double *X, int NX, char *line));
+int     iparse                 PROTO((int *X, int NX, char *line));
+int     iparse_csv             PROTO((int *X, int NX, char *line));
+int     tparse                 PROTO((time_t *X, int NX, char *line));
+int     tparse_csv             PROTO((time_t *X, int NX, char *line));
 int     fparse                 PROTO((float *X, int NX, char *line));
 int     get_argument           PROTO((int argc, char **argv, char *arg));
@@ -256 +264 @@
 int     check_dir_access       PROTO((char *path, int verbose));
 int     check_file_exec        PROTO((char *filename));
+char   *abspath                PROTO((char *oldpath, int maxlength));
 
 /* in glockfile.c */
@@ -323 +332 @@
 off_t   Fwrite                 PROTO((void *ptr, off_t size, off_t nitems, FILE *f, char *type));
 
+char   *memstr                 PROTO((char *m1, char *m2, int n));
+int     write_fmt              PROTO((int fd, char *format, ...));
+
 char   **isolate_elements      PROTO((int argc, char **argv, int *nstack));
 
@@ -332 +344 @@
 // gprint gets a stub implementation in libohana. opihi implements the real one.
 int    gprint (gpDest dest, char *format, ...);
+
+// rconnect is used to run remote programs with a pipe for communication
+typedef enum {
+  RCONNECT_ERR_NONE    = 0,
+  RCONNECT_ERR_EXEC    = 1,
+  RCONNECT_ERR_PIPE    = 2,
+  RCONNECT_ERR_CONNECT = 3,
+} RconnectErrors;
+
+void rconnect_set_timeout (int timeout);
+int rconnect (char *command, char *hostname, char *shell, int *stdio, int *errorInfo, int doHandshake);
 
 /*

trunk/Ohana/src/libohana/include/ohana_allocate.h

@@ -12 +12 @@
 OhanaMemstats ohana_memstats (int mode);
 
+/* EAM 2012.01.18 : comparative tests on my desktop 'pikake' (Intel Core 2 Quad) show a
+ * modest speed loss when using the Ohana memory managment stuff.  the tests runs a ~1.2M
+ * allocations followed by the same number of frees.  with the Ohana memory code, these
+ * ran at ~0.69 sec per block; without the time was ~0.56 sec per block
+ */
+
 /* default is to use basic system memory functions */
+
 # ifdef OHANA_MEMORY
 

trunk/Ohana/src/libohana/src/findexec.c

@@ -404 +404 @@
   return TRUE;
 }
+
+// ohana-based equivalent to 'realpath'.  realpath does not guarantee an absolute path (eg on Solaris), 
+// just a 'cannonical path'.  I don't care about resolving out links, just ensuring an absolute path
+// also, realpath is a bit ambiguous on the maxlength argument
+char *abspath (char *oldpath, int maxlength) {
+
+  if (!oldpath) return NULL;
+
+  if (oldpath[0] == '/') {
+    char *newpath = strcreate (oldpath);
+    return newpath;
+  }
+
+  char *cwd  = getcwd(NULL, maxlength);
+  if (cwd == NULL) {
+    // XXX need an error reporting function...
+    fprintf (stderr, "error getting cwd (longer than %d chars?)\n", maxlength);
+    return NULL;
+  }
+
+  char *newpath = NULL;
+
+  int Nbytes = strlen(cwd) + strlen(oldpath) + 2;
+  ALLOCATE (newpath, char, Nbytes);
+  snprintf (newpath, Nbytes, "%s/%s", cwd, oldpath);
+  return newpath;
+}

trunk/Ohana/src/libohana/src/string.c

@@ -143 +143 @@
 }
 
+int scan_line_maxlen (FILE *f, char *line, int maxlen) {
+
+  int i, status;
+  char c;
+  
+  status = EOF + 1;
+  
+  for (i = 0, c = 0; (c != '\n') && (status != EOF) && (i < maxlen); i++) {
+    status = fscanf (f, "%c", &c);
+    line[i] = c;
+  }
+  line[i - 1] = 0;  /* this could make things crash! */
+
+  if (i > 1) {
+    status = EOF + 1;
+  }
+
+  return (status);
+}
+
 char *_parse_nextword (char *string) {
 
@@ -203 +223 @@
   if (word[0] == '-') return (-1);
   return (1);
+}
+
+int iparse (int *X, int NX, char *line) {
+
+  int i;
+  char *word;
+  char *ptr;
+
+  word = line;
+  for (i = 0; i < NX - 1; i++)
+    word = _parse_nextword (word);
+
+  *X = strtol (word, &ptr, 0);
+  if (ptr == word) return (FALSE);
+  if (word[0] == '-') return (-1);
+  return (1);
+}
+
+int iparse_csv (int *X, int NX, char *line) {
+
+  int i;
+  char *word;
+  char *ptr;
+
+  word = line;
+  for (i = 0; i < NX - 1; i++)
+    word = _parse_nextword_csv (word);
+  
+  if (word[0] == '"') word[0] = ' ';
+  if (word[0] == ',') {
+      *X = 0;
+      return 1;
+  }
+
+  *X = strtol (word, &ptr, 0);
+  if (ptr == word) return (FALSE);
+  if (word[0] == '-') return (-1);
+  return (1);
+}
+
+int tparse (time_t *X, int NX, char *line) {
+
+  int i, status;
+  char *word;
+
+  word = line;
+  for (i = 0; i < NX - 1; i++)
+    word = _parse_nextword (word);
+
+  status = ohana_str_to_time (word, X);
+  if (!status) return (FALSE);
+  return (TRUE);
+}
+
+int tparse_csv (time_t *X, int NX, char *line) {
+
+  int i, status;
+  char *word;
+
+  word = line;
+  for (i = 0; i < NX - 1; i++)
+    word = _parse_nextword_csv (word);
+  
+  if (word[0] == '"') word[0] = ' ';
+  if (word[0] == ',') {
+      *X = 0;
+      return 1;
+  }
+
+  status = ohana_str_to_time (word, X);
+  if (!status) return (FALSE);
+  return (TRUE);
 }