de-layer Perlhost.h's 3 Malloc() classed + Cwd class

-Perl's primary malloc pool (per interp, never ithread shared), doesnt
 need CS mutexes, the refcounting/multiple my_perl owners infrastruture,
 etc. Inline the IPerlMem/VPerLMem class/struct direct into CPerlHost
 class. Less ptr derefs at runtime. Saves memory, because no malloc header.
 And remove the 0x24 ??? bytes on x86-32 CS/mutex struct.
-Use retval of libc's memset(), saves a non-vol reg push/pop/saving cycle.
 ZeroMemory() has void retval. Lack of a Calloc() API in VMem.h is for
 another time.
-"virtual int Chdir(const char *dirname);" remove virtual tag. It is
 unused ptr indirection. Also the secret C++ vtable ptr im CPerlHost
 objs is now gone.
-inline VDir obj into CPerlHost, VDir *s are not shared between interps.
-Sort machine type integer members of CPerlHost class by size. Remove
 Alignment holes.
-Speedup  win32_checkTLS(), win32_checkTLS() is probably redundant
 outside -DDEBUGGING nowadays, it was added in commit

222c300  1/13/2002 10:37:48 AM
Win32 fixes:
 - vmem.h hack to handle free-by-wrong-thread after eval "".

still will leave it in for now, just optimize it instead.

I benchmarked, 10000x calls to Perl_get_context() in a loop.
Retval ignored, is 126 us (microsec). 10000x calls to
GetCurrentThreadId(), is 34 us.

Author: bulk88

win32/perlhost.h

@@ -15,7 +15,13 @@
 #include <signal.h>
 #include <wchar.h>
 #include "iperlsys.h"
+
+#include "vmem.h"
+
+#define CRT_ALLOC_BASE
 #include "vmem.h"
+#undef CRT_ALLOC_BASE
+
 #include "vdir.h"
 
 #ifndef WC_NO_BEST_FIT_CHARS
@@ -38,6 +44,7 @@ class CPerlHost
                  const struct IPerlProc** ppProc);
     CPerlHost(CPerlHost& host);
     ~CPerlHost(void);
+    VMEM_H_NEW_OP;
 
     static CPerlHost* IPerlMem2Host(const struct IPerlMem** piPerl);
     static CPerlHost* IPerlMemShared2Host(const struct IPerlMem** piPerl);
@@ -56,20 +63,20 @@ class CPerlHost
 
 /* IPerlMem */
     /* Locks provided but should be unnecessary as this is private pool */
-    inline void* Malloc(size_t size) { return m_pVMem->Malloc(size); };
-    inline void* Realloc(void* ptr, size_t size) { return m_pVMem->Realloc(ptr, size); };
-    inline void Free(void* ptr) { m_pVMem->Free(ptr); };
+    inline void* Malloc(size_t size) { return m_VMem.Malloc(size); };
+    inline void* Realloc(void* ptr, size_t size) { return m_VMem.Realloc(ptr, size); };
+    inline void Free(void* ptr) { m_VMem.Free(ptr); };
     inline void* Calloc(size_t num, size_t size)
     {
         size_t count = num*size;
         void* lpVoid = Malloc(count);
         if (lpVoid)
-            ZeroMemory(lpVoid, count);
+            lpVoid = memset(lpVoid, 0, count);
         return lpVoid;
     };
-    inline void GetLock(void) { m_pVMem->GetLock(); };
-    inline void FreeLock(void) { m_pVMem->FreeLock(); };
-    inline int IsLocked(void) { return m_pVMem->IsLocked(); };
+    inline void GetLock(void) { m_VMem.GetLock(); };
+    inline void FreeLock(void) { m_VMem.FreeLock(); };
+    inline int IsLocked(void) { return m_VMem.IsLocked(); };
 
 /* IPerlMemShared */
     /* Locks used to serialize access to the pool */
@@ -103,7 +110,7 @@ class CPerlHost
         size_t count = num*size;
         void* lpVoid = MallocShared(count);
         if (lpVoid)
-            ZeroMemory(lpVoid, count);
+            lpVoid = memset(lpVoid, 0, count);
         return lpVoid;
     };
 
@@ -122,7 +129,7 @@ class CPerlHost
         size_t count = num*size;
         void* lpVoid = MallocParse(count);
         if (lpVoid)
-            ZeroMemory(lpVoid, count);
+            lpVoid = memset(lpVoid, 0, count);
         return lpVoid;
     };
 
@@ -137,7 +144,7 @@ class CPerlHost
             *len = strlen(e);
         return e;
     }
-    void* CreateChildEnv(void) { return CreateLocalEnvironmentStrings(*m_pvDir); };
+    void* CreateChildEnv(void) { return CreateLocalEnvironmentStrings(m_vDir); };
     void FreeChildEnv(void* pStr) { FreeLocalEnvironmentStrings((char*)pStr); };
     char* GetChildDir(void);
     void FreeChildDir(char* pStr);
@@ -166,7 +173,7 @@ class CPerlHost
 public:
 
 /* IPerlDIR */
-    virtual int Chdir(const char *dirname);
+    int Chdir(const char *dirname);
 
 /* IPerllProc */
     void Abort(void);
@@ -176,9 +183,10 @@ class CPerlHost
     int Execv(const char *cmdname, const char *const *argv);
     int Execvp(const char *cmdname, const char *const *argv);
 
+    inline VMem* GetMem(void) { return (VMem* )&m_VMem; };
     inline VMem* GetMemShared(void) { m_pVMemShared->AddRef(); return m_pVMemShared; };
     inline VMem* GetMemParse(void) { m_pVMemParse->AddRef(); return m_pVMemParse; };
-    inline VDir* GetDir(void) { return m_pvDir; };
+    inline VDir* GetDir(void) { return &m_vDir; };
 
 public:
 
@@ -192,22 +200,23 @@ class CPerlHost
     const struct IPerlSock*	    m_pHostperlSock;
     const struct IPerlProc*	    m_pHostperlProc;
 
-    inline char* MapPathA(const char *pInName) { return m_pvDir->MapPathA(pInName); };
-    inline WCHAR* MapPathW(const WCHAR *pInName) { return m_pvDir->MapPathW(pInName); };
+    inline char* MapPathA(const char *pInName) { return m_vDir.MapPathA(pInName); };
+    inline WCHAR* MapPathW(const WCHAR *pInName) { return m_vDir.MapPathW(pInName); };
+    inline operator VDir* () { return GetDir(); };
 protected:
-
-    VDir*   m_pvDir;
-    VMem*   m_pVMem;
+    VMemNL  m_VMem;
     VMem*   m_pVMemShared;
     VMem*   m_pVMemParse;
 
-    DWORD   m_dwEnvCount;
     LPSTR*  m_lppEnvList;
+    DWORD   m_dwEnvCount;
     BOOL    m_bTopLevel;	// is this a toplevel host?
     static long num_hosts;
 public:
     inline  int LastHost(void) { return num_hosts == 1L; };
     struct interpreter *host_perl;
+protected:
+    VDir   m_vDir;
 };
 
 long CPerlHost::num_hosts = 0L;
@@ -2110,12 +2119,11 @@ CPerlHost::CPerlHost(void)
 {
     /* Construct a host from scratch */
     InterlockedIncrement(&num_hosts);
-    m_pvDir = new VDir();
-    m_pVMem = new VMem();
+
     m_pVMemShared = new VMem();
     m_pVMemParse =  new VMem();
 
-    m_pvDir->Init(NULL, m_pVMem);
+    m_vDir.Init(NULL);
 
     m_dwEnvCount = 0;
     m_lppEnvList = NULL;
@@ -2150,12 +2158,11 @@ CPerlHost::CPerlHost(const struct IPerlMem** ppMem, const struct IPerlMem** ppMe
                  const struct IPerlProc** ppProc)
 {
     InterlockedIncrement(&num_hosts);
-    m_pvDir = new VDir(0);
-    m_pVMem = new VMem();
+
     m_pVMemShared = new VMem();
     m_pVMemParse =  new VMem();
 
-    m_pvDir->Init(NULL, m_pVMem);
+    m_vDir.Init(NULL, 0);
 
     m_dwEnvCount = 0;
     m_lppEnvList = NULL;
@@ -2177,13 +2184,12 @@ CPerlHost::CPerlHost(CPerlHost& host)
 {
     /* Construct a host from another host */
     InterlockedIncrement(&num_hosts);
-    m_pVMem = new VMem();
+
     m_pVMemShared = host.GetMemShared();
     m_pVMemParse =  host.GetMemParse();
 
     /* duplicate directory info */
-    m_pvDir = new VDir(0);
-    m_pvDir->Init(host.GetDir(), m_pVMem);
+    m_vDir.Init(host.GetDir(), 0);
 
     m_pHostperlMem	    = &perlMem;
     m_pHostperlMemShared    = &perlMemShared;
@@ -2210,10 +2216,10 @@ CPerlHost::~CPerlHost(void)
 {
     Reset();
     InterlockedDecrement(&num_hosts);
-    delete m_pvDir;
+    //delete m_vDir;
     m_pVMemParse->Release();
     m_pVMemShared->Release();
-    m_pVMem->Release();
+    //m_VMem.Release();
 }
 
 LPSTR
@@ -2360,7 +2366,7 @@ CPerlHost::GetChildDir(void)
     size_t length;
 
     Newx(ptr, MAX_PATH+1, char);
-    m_pvDir->GetCurrentDirectoryA(MAX_PATH+1, ptr);
+    m_vDir.GetCurrentDirectoryA(MAX_PATH+1, ptr);
     length = strlen(ptr);
     if (length > 3) {
         if ((ptr[length-1] == '\\') || (ptr[length-1] == '/'))
@@ -2546,11 +2552,19 @@ CPerlHost::Chdir(const char *dirname)
         errno = ENOENT;
         return -1;
     }
-    ret = m_pvDir->SetCurrentDirectoryA((char*)dirname);
+    ret = m_vDir.SetCurrentDirectoryA((char*)dirname);
     if(ret < 0) {
         errno = ENOENT;
     }
     return ret;
 }
 
+static inline VMemNL * VDToVM(VDir * pvd) {
+    VDir * vd = (VDir *)pvd;
+    size_t p_szt = ((size_t)vd)-((size_t)((CPerlHost*)NULL)->GetDir());
+    CPerlHost * cph = (CPerlHost*)p_szt;
+    VMemNL * vm = cph->GetMem();
+    return vm;
+}
+
 #endif /* ___PerlHost_H___ */

win32/perllib.c

@@ -49,10 +49,21 @@ xs_init(pTHX)
 void
 win32_checkTLS(PerlInterpreter *host_perl)
 {
-    dTHX;
-    if (host_perl != my_perl) {
-        int *nowhere = NULL;
-        abort();
+/* GCurThdId() is lightweight, but b/c of the ctrl-c/signals sometimes firing
+  in other random WinOS threads, that make the TIDs go out of sync.
+  This isn't always an error, although high chance of a SEGV in the next
+  couple milliseconds b/c of "Day 1 of Win32 port" Ctrl-C vs Perl bugs.
+  Google it for details.  So this code, if TIDs don't match, do the full heavy
+  TlsGetValue() + misc fn calls.  Then resync TIDs to keep this fast for
+  future calls to this fn. */
+    DWORD tid = GetCurrentThreadId();
+    if(tid != host_perl->Isys_intern.cur_tid) {
+        dTHX; /* heavyweight */
+        if (host_perl != my_perl) {
+            int *nowhere = NULL;
+            abort();
+        }
+        host_perl->Isys_intern.cur_tid = tid;
     }
 }
 

win32/vdir.h

@@ -23,12 +23,15 @@ class VDir
     VDir(int bManageDir = 1);
     ~VDir() {};
 
-    void Init(VDir* pDir, VMem *pMem);
+    VMEM_H_NEW_OP;
+    void Init(VDir* pDirCloneFrom);
+    void Init(VDir* pDirCloneFrom, int bManageDir);
     void SetDefaultA(char const *pDefault);
     void SetDefaultW(WCHAR const *pDefault);
     char* MapPathA(const char *pInName);
     WCHAR* MapPathW(const WCHAR *pInName);
-    int SetCurrentDirectoryA(char *lpBuffer);
+    /* CPerlHost::Chdir() is the only caller */
+    inline int SetCurrentDirectoryA(char *lpBuffer);
     int SetCurrentDirectoryW(WCHAR *lpBuffer);
     inline int GetDefault(void) { return nDefault; };
 
@@ -116,36 +119,52 @@ class VDir
         return (chr | 0x20)-'a';
     };
 
-    VMem *pMem;
-    int nDefault, bManageDirectory;
-    char *dirTableA[driveCount];
-    char szLocalBufferA[MAX_PATH+1];
+/* Former "VMem *" member, just C-ptr-cast the VDir * to a CPerlHost *
+   and get the "VMem *" directly vs 2 copies of the ptr. */
+#define pMem VDToVM(this)
+
     WCHAR *dirTableW[driveCount];
+    char *dirTableA[driveCount];
+    int nDefault;
+
+    inline void * ZeroMemStart(void) {return (void *)dirTableW;};
+    inline size_t ZeroMemSize(void) {
+        return ((size_t)&nDefault)+sizeof(nDefault)-((size_t)dirTableW);
+    };
+
     WCHAR szLocalBufferW[MAX_PATH+1];
+    char szLocalBufferA[MAX_PATH+1];
+    bool bManageDirectory;
+
 };
 
+static inline VMemNL * VDToVM(VDir * vd);
 
 VDir::VDir(int bManageDir /* = 1 */)
 {
-    nDefault = 0;
+    /* combine all fields needed Nulling into 1 call */
+    memset(ZeroMemStart(), 0, ZeroMemSize());
+    bManageDirectory = bManageDir;
+}
+
+void VDir::Init(VDir* pDirCloneFrom, int bManageDir)
+{
     bManageDirectory = bManageDir;
-    memset(dirTableA, 0, sizeof(dirTableA));
-    memset(dirTableW, 0, sizeof(dirTableW));
+    VDir::Init(pDirCloneFrom);
 }
 
-void VDir::Init(VDir* pDir, VMem *p)
+void VDir::Init(VDir* pDirCloneFrom)
 {
     int index;
 
-    pMem = p;
-    if (pDir) {
+    if (pDirCloneFrom) {
         for (index = 0; index < driveCount; ++index) {
-            SetDirW(pDir->GetDirW(index), index);
+            SetDirW(pDirCloneFrom->GetDirW(index), index);
         }
-        nDefault = pDir->GetDefault();
+        nDefault = pDirCloneFrom->GetDefault();
     }
     else {
-        int bSave = bManageDirectory;
+        bool bSave = bManageDirectory;
         DWORD driveBits = GetLogicalDrives();
 
         bManageDirectory = 0;