Merge pull request #221 from justadudewhohacks/external-mem-tracking-followup

External mem tracking followup

Author: justadudewhohacks

appveyor.yml

@@ -54,4 +54,5 @@ test_script:
   - node --version
   - cmd: cd c:\projects\opencv4nodejs\test
   - npm install
-  - npm run test-appveyor
+  - npm run test-appveyor
+  - npm run test-externalMemTracking

binding.gyp

@@ -17,11 +17,12 @@
 		],
 		"sources": [
 			"cc/opencv4nodejs.cc",
+			"cc/CustomMatAllocator.cc",
+			"cc/ExternalMemTracking.cc",
 			"cc/cvTypes/cvTypes.cc",
 			"cc/cvTypes/imgprocConstants.cc",
 			"cc/cvTypes/videoCaptureProps.cc",
 			"cc/core/core.cc",
-			"cc/core/CustomAllocator.cc",
 			"cc/core/Mat.cc",
 			"cc/core/MatImgproc.cc",
 			"cc/core/MatCalib3d.cc",

cc/core/CustomAllocator.cc renamed to cc/CustomMatAllocator.cc

@@ -1,6 +1,4 @@
-
-
-#include "CustomAllocator.h"
+#include "CustomMatAllocator.h"
 //#include <iostream>
 
 #ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
@@ -9,7 +7,7 @@ cv::UMatData* CustomMatAllocator::allocate(int dims, const int* sizes, int type,
                        void* data0, size_t* step, int flags, cv::UMatUsageFlags usageFlags) const
 {
     cv::UMatData* u = stdAllocator->allocate(dims, sizes, type, data0, step, flags, usageFlags);
-    
+
     if (NULL != u){
         u->prevAllocator = u->currAllocator = this;
         if( !(u->flags & cv::UMatData::USER_ALLOCATED) ){
@@ -21,7 +19,7 @@ cv::UMatData* CustomMatAllocator::allocate(int dims, const int* sizes, int type,
                 variables->MemTotalChangeMutex.unlock();
                 this->FixupJSMem();
             } catch (...){
-                printf("exception adjusting memory\n");
+                printf("CustomMatAllocator::allocate - exception adjusting memory\n");
             }
         }
     }
@@ -95,7 +93,7 @@ void CustomMatAllocator::FixupJSMem() const {
         int64_t adjust = variables->TotalMem - variables->TotalJSMem;
         variables->TotalJSMem += adjust;
         variables->MemTotalChangeMutex.unlock();
-        
+
         if (adjust){
             //printf("will call Nan ajust by %d\n", (int)adjust);
             Nan::AdjustExternalMemory(adjust);

cc/core/CustomAllocator.h renamed to cc/CustomMatAllocator.h

@@ -1,6 +1,5 @@
-#ifndef __FF_CUSTOMALLOCATOR_H__
-#define __FF_CUSTOMALLOCATOR_H__
-
+#ifndef __FF_CUSTOMATMALLOCATOR_H__
+#define __FF_CUSTOMATMALLOCATOR_H__
 
 #include <thread>
 #include <stdint.h>
@@ -23,15 +22,12 @@
 
 #ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
 
-// un-comment to enable by default
-// #define OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING_DEFAULT_ON
-
 class CustomMatAllocator : public cv::MatAllocator
 {
 public:
     // strange evilness of the functions being tagged const means that the fns cant change
     // stuff in the class instance.
-    // so instead create constant pointer to a structure which we are allowed to change, even 
+    // so instead create constant pointer to a structure which we are allowed to change, even
     // from a const function.
     typedef struct tag_Variables {
         cv::Mutex MemTotalChangeMutex;
@@ -44,17 +40,17 @@ class CustomMatAllocator : public cv::MatAllocator
         std::thread::id main_thread_id;
     } VARIABLES;
 
-    CustomMatAllocator( ) { 
-        stdAllocator = cv::Mat::getStdAllocator(); 
+    CustomMatAllocator( ) {
+        stdAllocator = cv::Mat::getStdAllocator();
         variables = new VARIABLES;
         variables->TotalMem = 0; // total mem allocated by this allocator
         variables->CountMemAllocs = 0;
         variables->CountMemDeAllocs = 0;
         variables->TotalJSMem = 0; // total mem told to JS so far
-        
+
         variables->main_thread_id = std::this_thread::get_id();
     }
-    ~CustomMatAllocator( ) { 
+    ~CustomMatAllocator( ) {
         delete variables;
         variables = NULL;
     }
@@ -72,10 +68,10 @@ class CustomMatAllocator : public cv::MatAllocator
     // function which adjusts NAN mem to match allocated mem.
     // WILL ONLY ACTUALLY DO ANYTHING FROM MAIN JS LOOP
     void FixupJSMem() const;
-    
+
 
     VARIABLES *variables;
-    
+
     const cv::MatAllocator* stdAllocator;
 };
 

cc/ExternalMemTracking.cc

@@ -0,0 +1,100 @@
+#include "ExternalMemTracking.h"
+#include <iostream>
+
+#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
+CustomMatAllocator *ExternalMemTracking::custommatallocator = NULL;
+#endif
+
+NAN_MODULE_INIT(ExternalMemTracking::Init) {
+#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
+	try {
+		char* env = std::getenv("OPENCV4NODEJS_DISABLE_EXTERNAL_MEM_TRACKING");
+		if (env == NULL && custommatallocator == NULL) {
+			custommatallocator = new CustomMatAllocator();
+			cv::Mat::setDefaultAllocator(custommatallocator);
+		}
+	}
+	catch (...) {
+		printf("ExternalMemTracking::Init - fatal exception while trying to read env: OPENCV4NODEJS_DISABLE_EXTERNAL_MEM_TRACKING");
+	}
+#endif  
+	Nan::SetMethod(target, "isCustomMatAllocatorEnabled", IsCustomMatAllocatorEnabled);
+	Nan::SetMethod(target, "dangerousEnableCustomMatAllocator", DangerousEnableCustomMatAllocator);
+	Nan::SetMethod(target, "dangerousDisableCustomMatAllocator", DangerousDisableCustomMatAllocator);
+	Nan::SetMethod(target, "getMemMetrics", GetMemMetrics);
+};
+
+NAN_METHOD(ExternalMemTracking::GetMemMetrics) {
+
+  int64_t TotalAlloc = -1;
+  int64_t TotalKnownByJS = -1;
+  int64_t NumAllocations = -1;
+  int64_t NumDeAllocations = -1;
+
+#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
+  if (ExternalMemTracking::custommatallocator != NULL){
+    TotalAlloc = ExternalMemTracking::custommatallocator->readtotalmem();
+    TotalKnownByJS = ExternalMemTracking::custommatallocator->readmeminformed();
+    NumAllocations = ExternalMemTracking::custommatallocator->readnumallocated();
+    NumDeAllocations = ExternalMemTracking::custommatallocator->readnumdeallocated();
+  }
+#endif
+
+  FF_OBJ result = FF_NEW_OBJ();
+  Nan::Set(result, FF_NEW_STRING("TotalAlloc"), Nan::New((double)TotalAlloc));
+  Nan::Set(result, FF_NEW_STRING("TotalKnownByJS"), Nan::New((double)TotalKnownByJS));
+  Nan::Set(result, FF_NEW_STRING("NumAllocations"), Nan::New((double)NumAllocations));
+  Nan::Set(result, FF_NEW_STRING("NumDeAllocations"), Nan::New((double)NumDeAllocations));
+
+  info.GetReturnValue().Set(result);
+  return;
+}
+
+
+NAN_METHOD(ExternalMemTracking::IsCustomMatAllocatorEnabled) {
+    bool allocatorOn = false;
+#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
+    if (ExternalMemTracking::custommatallocator != NULL){
+		allocatorOn = true;
+    }
+#endif
+    info.GetReturnValue().Set(allocatorOn);
+}
+
+NAN_METHOD(ExternalMemTracking::DangerousEnableCustomMatAllocator) {
+	bool success = false;
+#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
+	if (ExternalMemTracking::custommatallocator == NULL) {
+		ExternalMemTracking::custommatallocator = new CustomMatAllocator();
+		cv::Mat::setDefaultAllocator(ExternalMemTracking::custommatallocator);
+	}
+	success = ExternalMemTracking::custommatallocator != NULL;
+#endif
+	info.GetReturnValue().Set(success);
+}
+
+NAN_METHOD(ExternalMemTracking::DangerousDisableCustomMatAllocator) {
+	bool success = false;
+#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
+	if (ExternalMemTracking::custommatallocator != NULL) {
+		CustomMatAllocator *allocator = ExternalMemTracking::custommatallocator;
+
+		// return default allocator
+		if (allocator->variables) {
+			allocator->variables->MemTotalChangeMutex.lock();
+		}
+		cv::Mat::setDefaultAllocator(NULL);
+		ExternalMemTracking::custommatallocator = NULL;
+		if (allocator->variables) {
+			allocator->variables->MemTotalChangeMutex.unlock();
+		}
+
+		// sorry, can't delete it, since it may be references by a number of outstanding Mats -> memory leak, but it's small
+		// and should not happen often, or ever!.
+		//delete allocator;
+	}
+	success = ExternalMemTracking::custommatallocator == NULL;
+#endif
+	info.GetReturnValue().Set(success);
+}
+

cc/ExternalMemTracking.h

@@ -0,0 +1,30 @@
+#include "macros.h"
+#include "CustomMatAllocator.h"
+
+#ifndef __FF_EXTERNALMEMTRACKING_H__
+#define __FF_EXTERNALMEMTRACKING_H__
+
+class ExternalMemTracking {
+public:
+
+#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
+	static CustomMatAllocator *custommatallocator;
+#endif
+
+	static inline void onMatAllocated() {
+#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
+		if (custommatallocator != NULL) {
+			custommatallocator->FixupJSMem();
+		}
+#endif
+	}
+
+	static NAN_MODULE_INIT(Init);
+	static NAN_METHOD(IsCustomMatAllocatorEnabled);
+	static NAN_METHOD(GetMemMetrics);
+	static NAN_METHOD(DangerousEnableCustomMatAllocator);
+	static NAN_METHOD(DangerousDisableCustomMatAllocator);
+
+};
+
+#endif

cc/core/Mat.cc

@@ -1,29 +1,11 @@
 #include "Mat.h"
 #include "MatImgproc.h"
 #include "MatCalib3d.h"
-
+#include "ExternalMemTracking.h"
 
 Nan::Persistent<v8::FunctionTemplate> Mat::constructor;
 
-#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
-CustomMatAllocator *Mat::custommatallocator = NULL;
-#endif  
-
-
 NAN_MODULE_INIT(Mat::Init) {
-    
-// defined in CustomAllocator.h, depends on ocv >= 3.1.0
-#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
-
-// defined in CustomAllocator.h
-#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING_DEFAULT_ON
-  if (NULL == custommatallocator){
-    custommatallocator = new CustomMatAllocator();
-    cv::Mat::setDefaultAllocator(custommatallocator);
-  }
-#endif
-  
-#endif  
 
   v8::Local<v8::FunctionTemplate> ctor = Nan::New<v8::FunctionTemplate>(Mat::New);
   constructor.Reset(ctor);
@@ -193,14 +175,11 @@ NAN_METHOD(Mat::New) {
 	}
 	self->Wrap(info.Holder());
 
-#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
-    // I *think* New should be called in JS thread where cv::mat has been created async,
+	// if ExternalMemTracking is disabled, the following instruction will be a no op
+    // notes: I *think* New should be called in JS thread where cv::mat has been created async,
     // so a good place to rationalise memory
-    if (self->custommatallocator){
-        self->custommatallocator->FixupJSMem();
-    }
-#endif
-    
+	ExternalMemTracking::onMatAllocated();
+
 	FF_RETURN(info.Holder());
 }
 

cc/core/Mat.h

@@ -8,20 +8,14 @@
 #include "RotatedRect.h"
 #include "Workers.h"
 
-#include "CustomAllocator.h"
-
 #ifndef __FF_MAT_H__
 #define __FF_MAT_H__
 
 class Mat : public Nan::ObjectWrap {
 public:
-  cv::Mat mat;
+	cv::Mat mat;
 
-#ifdef OPENCV4NODEJS_ENABLE_EXTERNALMEMTRACKING
-  static CustomMatAllocator *custommatallocator;
-#endif
-
-  static NAN_MODULE_INIT(Init);
+	static NAN_MODULE_INIT(Init);
 	static NAN_METHOD(New);
 
 	static NAN_METHOD(Eye);