Move memory related functions to memory.[ch]pp

cmake/NeuronFileLists.cmake

@@ -39,6 +39,7 @@ set(HEADER_FILES_TO_INSTALL
     oc/hocparse.h
     oc/mcran4.h
     oc/mech_api.h
+    oc/memory.hpp
     oc/nrnapi.h
     oc/nrnassrt.h
     oc/nrnisaac.h
@@ -101,6 +102,7 @@ set(OC_FILE_LIST
     hoc_oop.cpp
     list.cpp
     math.cpp
+    memory.cpp
     mswinprt.cpp
     nonlin.cpp
     ocerf.cpp

src/oc/hocdec.h

@@ -224,10 +224,6 @@ struct HocParmUnits { /* units for symbol values */
 
 #include "oc_ansi.h"
 
-void* emalloc(size_t n);
-void* ecalloc(size_t n, size_t size);
-void* erealloc(void* ptr, size_t n);
-
 extern Inst *hoc_progp, *hoc_progbase, *hoc_prog, *hoc_prog_parse_recover;
 extern Inst* hoc_pc;
 

src/oc/memory.cpp

@@ -0,0 +1,112 @@
+#include "memory.hpp"
+
+#include <cstdlib>
+#include <cstring>
+
+// For hoc_warning and hoc_execerror
+#include "oc_ansi.h"
+
+#if HAVE_POSIX_MEMALIGN
+#define HAVE_MEMALIGN 1
+#endif
+#if defined(DARWIN) /* posix_memalign seems not to work on Darwin 10.6.2 */
+#undef HAVE_MEMALIGN
+#endif
+#if HAVE_MEMALIGN
+#undef _XOPEN_SOURCE /* avoid warnings about redefining this */
+#define _XOPEN_SOURCE 600
+#endif
+
+static bool emalloc_error = false;
+
+void* hoc_Emalloc(std::size_t n) { /* check return from malloc */
+    void* p = std::malloc(n);
+    if (p == nullptr) {
+        emalloc_error = true;
+    }
+    return p;
+}
+
+void* hoc_Ecalloc(std::size_t n, std::size_t size) { /* check return from calloc */
+    if (n == 0) {
+        return nullptr;
+    }
+    void* p = std::calloc(n, size);
+    if (p == nullptr) {
+        emalloc_error = true;
+    }
+    return p;
+}
+
+void* hoc_Erealloc(void* ptr, std::size_t size) { /* check return from realloc */
+    if (!ptr) {
+        return hoc_Emalloc(size);
+    }
+    void* p = std::realloc(ptr, size);
+    if (p == nullptr) {
+        std::free(ptr);
+        emalloc_error = true;
+    }
+    return p;
+}
+
+void hoc_malchk(void) {
+    if (emalloc_error) {
+        emalloc_error = false;
+        hoc_execerror("out of memory", nullptr);
+    }
+}
+
+void* emalloc(std::size_t n) {
+    void* p = hoc_Emalloc(n);
+    if (emalloc_error) {
+        hoc_malchk();
+    }
+    return p;
+}
+
+void* ecalloc(std::size_t n, std::size_t size) {
+    void* p = hoc_Ecalloc(n, size);
+    if (emalloc_error) {
+        hoc_malchk();
+    }
+    return p;
+}
+
+void* erealloc(void* ptr, std::size_t size) {
+    void* p = hoc_Erealloc(ptr, size);
+    if (emalloc_error) {
+        hoc_malchk();
+    }
+    return p;
+}
+
+void* nrn_cacheline_alloc(void** memptr, std::size_t size) {
+#if HAVE_MEMALIGN
+    static bool memalign_is_working = true;
+    if (memalign_is_working) {
+        if (posix_memalign(memptr, 64, size) != 0) {
+            hoc_warning("posix_memalign not working, falling back to using malloc\n", nullptr);
+            memalign_is_working = false;
+            *memptr = hoc_Emalloc(size);
+            hoc_malchk();
+        }
+    } else
+#endif
+    {
+        *memptr = hoc_Emalloc(size);
+        hoc_malchk();
+    }
+    return *memptr;
+}
+
+void* nrn_cacheline_calloc(void** memptr, std::size_t nmemb, std::size_t size) {
+#if HAVE_MEMALIGN
+    nrn_cacheline_alloc(memptr, nmemb * size);
+    std::memset(*memptr, 0, nmemb * size);
+#else
+    *memptr = hoc_Ecalloc(nmemb, size);
+    hoc_malchk();
+#endif
+    return *memptr;
+}

src/oc/memory.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+// Some functions here are prepend with 'hoc_' but they are unrelated to hoc itself.
+#include <cstddef>
+
+/* check return from malloc */
+void* hoc_Emalloc(std::size_t n);
+void* hoc_Ecalloc(std::size_t n, std::size_t size);
+void* hoc_Erealloc(void* ptr, std::size_t size);
+
+void hoc_malchk(void);
+
+void* emalloc(std::size_t n);
+void* ecalloc(std::size_t n, std::size_t size);
+void* erealloc(void* ptr, std::size_t size);
+
+void* nrn_cacheline_alloc(void** memptr, std::size_t size);
+void* nrn_cacheline_calloc(void** memptr, std::size_t nmemb, std::size_t size);

src/oc/oc_ansi.h

@@ -8,6 +8,8 @@
 #include <stdexcept>
 #include <string>
 #include <string_view>
+
+#include "memory.hpp"
 /**
  * \dir
  * \brief HOC Interpreter
@@ -49,9 +51,6 @@ void ivoc_help(const char*);
 
 Symbol* hoc_lookup(const char*);
 
-void* hoc_Ecalloc(std::size_t nmemb, std::size_t size);
-void* hoc_Emalloc(size_t size);
-void hoc_malchk();
 [[noreturn]] void hoc_execerror(const char*, const char*);
 [[noreturn]] void hoc_execerr_ext(const char* fmt, ...);
 char* hoc_object_name(Object*);
@@ -320,10 +319,6 @@ void hoc_obj_set(int i, Object*);
 void nrn_hoc_lock();
 void nrn_hoc_unlock();
 
-void* hoc_Erealloc(void* ptr, std::size_t size);
-
-void* nrn_cacheline_alloc(void** memptr, std::size_t size);
-void* nrn_cacheline_calloc(void** memptr, std::size_t nmemb, std::size_t size);
 [[noreturn]] void nrn_exit(int);
 void hoc_free_list(Symlist**);
 int hoc_errno_check();

src/oc/symbol.cpp

@@ -2,17 +2,6 @@
 /* /local/src/master/nrn/src/oc/symbol.cpp,v 1.9 1999/02/25 18:01:58 hines Exp */
 /* version 7.2.1 2-jan-89 */
 
-#if HAVE_POSIX_MEMALIGN
-#define HAVE_MEMALIGN 1
-#endif
-#if defined(DARWIN) /* posix_memalign seems not to work on Darwin 10.6.2 */
-#undef HAVE_MEMALIGN
-#endif
-#if HAVE_MEMALIGN
-#undef _XOPEN_SOURCE /* avoid warnings about redefining this */
-#define _XOPEN_SOURCE 600
-#endif
-
 #include "hoc.h"
 #include "hocdec.h"
 #include "hoclist.h"
@@ -173,96 +162,6 @@ void hoc_link_symbol(Symbol* sp, Symlist* list) {
     sp->next = nullptr;
 }
 
-static int emalloc_error = 0;
-
-void hoc_malchk(void) {
-    if (emalloc_error) {
-        emalloc_error = 0;
-        execerror("out of memory", nullptr);
-    }
-}
-
-void* hoc_Emalloc(size_t n) { /* check return from malloc */
-    void* p = malloc(n);
-    if (p == nullptr)
-        emalloc_error = 1;
-    return p;
-}
-
-void* emalloc(size_t n) {
-    void* p = hoc_Emalloc(n);
-    if (emalloc_error) {
-        hoc_malchk();
-    }
-    return p;
-}
-
-void* hoc_Ecalloc(size_t n, size_t size) { /* check return from calloc */
-    if (n == 0) {
-        return nullptr;
-    }
-    void* p = calloc(n, size);
-    if (p == nullptr)
-        emalloc_error = 1;
-    return p;
-}
-
-void* ecalloc(size_t n, size_t size) {
-    void* p = hoc_Ecalloc(n, size);
-    if (emalloc_error) {
-        hoc_malchk();
-    }
-    return p;
-}
-
-void* nrn_cacheline_alloc(void** memptr, size_t size) {
-#if HAVE_MEMALIGN
-    static int memalign_is_working = 1;
-    if (memalign_is_working) {
-        if (posix_memalign(memptr, 64, size) != 0) {
-            fprintf(stderr, "posix_memalign not working, falling back to using malloc\n");
-            memalign_is_working = 0;
-            *memptr = hoc_Emalloc(size);
-            hoc_malchk();
-        }
-    } else
-#endif
-        *memptr = hoc_Emalloc(size);
-    hoc_malchk();
-    return *memptr;
-}
-
-void* nrn_cacheline_calloc(void** memptr, size_t nmemb, size_t size) {
-#if HAVE_MEMALIGN
-    nrn_cacheline_alloc(memptr, nmemb * size);
-    memset(*memptr, 0, nmemb * size);
-#else
-    *memptr = hoc_Ecalloc(nmemb, size);
-    hoc_malchk();
-#endif
-    return *memptr;
-}
-
-void* hoc_Erealloc(void* ptr, size_t size) { /* check return from realloc */
-    if (!ptr) {
-        return hoc_Emalloc(size);
-    }
-    void* p = realloc(ptr, size);
-    if (p == nullptr) {
-        free(ptr);
-        emalloc_error = 1;
-    }
-    return p;
-}
-
-void* erealloc(void* ptr, size_t size) {
-    void* p = hoc_Erealloc(ptr, size);
-    if (emalloc_error) {
-        hoc_malchk();
-    }
-    return p;
-}
-
 void hoc_free_symspace(Symbol* s1) { /* frees symbol space. Marks it UNDEF */
     if (s1 && s1->cpublic != 2) {
         switch (s1->type) {