Add FFI caching in FFICall initialization

Author: tdermendjiev

examples/Gameraww/app/MasterViewController.js

@@ -87,4 +87,4 @@ var JSMasterViewController = UITableViewController.extend(
         "aboutPressed:" :
             {returns : interop.types.void, params : [ UIControl ]}
       }
-    });
+    });

src/NativeScript/CMakeLists.txt

@@ -1,4 +1,5 @@
 set(HEADER_FILES
+    Calling/FFICache.h	
     Calling/FFICall.h
     Calling/FFICallback.h
     Calling/FFICallbackInlines.h
@@ -102,6 +103,7 @@ set(HEADER_FILES
 )
 
 set(SOURCE_FILES
+    Calling/FFICache.cpp
     Calling/FFICall.cpp
     Calling/FFICallPrototype.cpp
     Calling/FFIFunctionCall.mm

src/NativeScript/Calling/FFICache.cpp

@@ -0,0 +1,23 @@
+//
+//  FFICache.cpp
+//  NativeScript
+//
+//  Created by Teodor Dermendzhiev on 02/10/2017.
+//  Copyright (c) 2014 г. Telerik. All rights reserved.
+//
+
+#include "FFICache.h"
+#include <stdio.h>
+
+namespace NativeScript {
+
+FFICache* FFICache::global() {
+
+    static FFICache* instance;
+
+    if (!instance)
+        instance = new FFICache;
+    return instance;
+}
+
+} // namespace NativeScript

src/NativeScript/Calling/FFICache.h

@@ -0,0 +1,39 @@
+//
+//  FFICache.h
+//  NativeScript
+//
+//  Created by Teodor Dermendzhiev on 02/10/2017.
+//
+//
+
+#ifndef __NativeScript__FFICache__
+#define __NativeScript__FFICache__
+
+#include "FFIType.h"
+#include <vector>
+
+namespace NativeScript {
+
+struct SignatureHash {
+
+    std::size_t operator()(std::vector<const ffi_type*> signature) const {
+        std::size_t seed = 2166136261;
+
+        for (size_t i = 0; i < signature.size(); i++) {
+            seed = (seed ^ reinterpret_cast<size_t>(signature[i])) * 16777619U;
+        }
+        return seed;
+    }
+};
+
+class FFICache {
+
+public:
+    std::unordered_map<std::vector<const ffi_type*>, std::shared_ptr<ffi_cif>, SignatureHash> cifCache;
+
+    static FFICache* global();
+};
+
+} // namespace NativeScript
+
+#endif /* FFICache_h */

src/NativeScript/Calling/FFICall.cpp

@@ -7,6 +7,7 @@
 //
 
 #include "FFICall.h"
+#include "FFICache.h"
 #include <JavaScriptCore/Interpreter.h>
 #include <JavaScriptCore/JSPromiseDeferred.h>
 #include <JavaScriptCore/StrongInlines.h>
@@ -18,9 +19,12 @@ using namespace JSC;
 
 const ClassInfo FFICall::s_info = { "FFICall", &Base::s_info, 0, CREATE_METHOD_TABLE(FFICall) };
 
-void FFICall::initializeFFI(VM& vm, const InvocationHooks& hooks, JSCell* returnType, const Vector<JSCell*>& parameterTypes, size_t initialArgumentIndex) {
-    ASSERT(this->methodTable()->destroy != FFICall::destroy);
+void deleteCif(ffi_cif* cif) {
+    delete[] cif->arg_types;
+    delete cif;
+}
 
+void FFICall::initializeFFI(VM& vm, const InvocationHooks& hooks, JSCell* returnType, const Vector<JSCell*>& parameterTypes, size_t initialArgumentIndex) {
     this->_invocationHooks = hooks;
 
     this->_initialArgumentIndex = initialArgumentIndex;
@@ -33,8 +37,11 @@ void FFICall::initializeFFI(VM& vm, const InvocationHooks& hooks, JSCell* return
 
     const ffi_type** parameterTypesFFITypes = new const ffi_type*[parametersCount + initialArgumentIndex];
 
+    this->signatureVector.push_back(getFFITypeMethodTable(returnType).ffiType);
+
     for (size_t i = 0; i < initialArgumentIndex; ++i) {
         parameterTypesFFITypes[i] = &ffi_type_pointer;
+        this->signatureVector.push_back(&ffi_type_pointer);
     }
 
     for (size_t i = 0; i < parametersCount; i++) {
@@ -45,10 +52,10 @@ void FFICall::initializeFFI(VM& vm, const InvocationHooks& hooks, JSCell* return
         this->_parameterTypes.append(ffiTypeMethodTable);
 
         parameterTypesFFITypes[i + initialArgumentIndex] = ffiTypeMethodTable.ffiType;
+        this->signatureVector.push_back(parameterTypesFFITypes[i + initialArgumentIndex]);
     }
 
-    this->_cif = new ffi_cif;
-    ffi_prep_cif(this->_cif, FFI_DEFAULT_ABI, parametersCount + initialArgumentIndex, const_cast<ffi_type*>(this->_returnType.ffiType), const_cast<ffi_type**>(parameterTypesFFITypes));
+    this->_cif = checkForExistingCif(parametersCount + initialArgumentIndex, const_cast<ffi_type*>(this->_returnType.ffiType), const_cast<ffi_type**>(parameterTypesFFITypes));
 
     this->_argsCount = _cif->nargs;
     this->_stackSize = 0;
@@ -57,17 +64,34 @@ void FFICall::initializeFFI(VM& vm, const InvocationHooks& hooks, JSCell* return
     this->_stackSize += malloc_good_size(sizeof(void * [this->_cif->nargs]));
 
     this->_returnOffset = this->_stackSize;
-    this->_stackSize += malloc_good_size(std::max(this->_cif->rtype->size, sizeof(ffi_arg)));
+    this->_stackSize += malloc_good_size(std::max(this->_cif.get()->rtype->size, sizeof(ffi_arg)));
 
     for (size_t i = 0; i < this->_argsCount; i++) {
         this->_argValueOffsets.push_back(this->_stackSize);
         this->_stackSize += malloc_good_size(std::max(this->_cif->arg_types[i]->size, sizeof(ffi_arg)));
     }
 }
 
+std::shared_ptr<ffi_cif> FFICall::checkForExistingCif(unsigned int nargs, ffi_type* rtype, ffi_type** atypes) {
+
+    std::unordered_map<std::vector<const ffi_type*>, std::shared_ptr<ffi_cif>, SignatureHash>::const_iterator it = FFICache::global()->cifCache.find(this->signatureVector);
+
+    if (it == FFICache::global()->cifCache.end()) {
+        std::shared_ptr<ffi_cif> shared(new ffi_cif, deleteCif);
+        ffi_prep_cif(shared.get(), FFI_DEFAULT_ABI, nargs, rtype, atypes);
+        FFICache::global()->cifCache[this->signatureVector] = shared;
+    }
+
+    return FFICache::global()->cifCache[this->signatureVector];
+}
+
 FFICall::~FFICall() {
-    delete[] this->_cif->arg_types;
-    delete this->_cif;
+
+    if (this->_cif.use_count() == 2) {
+        std::unordered_map<std::vector<const ffi_type*>, std::shared_ptr<ffi_cif>, SignatureHash>::const_iterator it;
+        it = FFICache::global()->cifCache.find(this->signatureVector);
+        FFICache::global()->cifCache.erase(it);
+    }
 }
 
 void FFICall::visitChildren(JSCell* cell, SlotVisitor& visitor) {
@@ -99,7 +123,7 @@ EncodedJSValue JSC_HOST_CALL FFICall::call(ExecState* execState) {
 
     {
         JSLock::DropAllLocks locksDropper(execState);
-        ffi_call(callee->_cif, FFI_FN(invocation.function), invocation._buffer + callee->_returnOffset, reinterpret_cast<void**>(invocation._buffer + callee->_argsArrayOffset));
+        ffi_call(callee->_cif.get(), FFI_FN(invocation.function), invocation._buffer + callee->_returnOffset, reinterpret_cast<void**>(invocation._buffer + callee->_argsArrayOffset));
     }
 
     JSValue result = callee->_returnType.read(execState, invocation._buffer + callee->_returnOffset, callee->_returnTypeCell.get());
@@ -150,7 +174,7 @@ JSObject* FFICall::async(ExecState* execState, JSValue thisValue, const ArgList&
       JSC::VM& vm = fakeExecState->vm();
       auto scope = DECLARE_CATCH_SCOPE(vm);
 
-      ffi_call(callee->_cif, FFI_FN(invocation->function), invocation->resultBuffer(), reinterpret_cast<void**>(invocation->_buffer + callee->_argsArrayOffset));
+      ffi_call(callee->_cif.get(), FFI_FN(invocation->function), invocation->resultBuffer(), reinterpret_cast<void**>(invocation->_buffer + callee->_argsArrayOffset));
 
       JSLockHolder lockHolder(fakeExecState);
       // we no longer have a valid caller on the stack, what with being async and all
@@ -189,4 +213,4 @@ JSObject* FFICall::async(ExecState* execState, JSValue thisValue, const ArgList&
 
     return deferred->promise();
 }
-}
+} // namespace NativeScript

src/NativeScript/Calling/FFICall.h

@@ -26,6 +26,9 @@ class FFICall : public JSC::InternalFunction {
     }
 
     JSC::JSObject* async(JSC::ExecState*, JSC::JSValue thisValue, const JSC::ArgList&);
+    std::shared_ptr<ffi_cif> checkForExistingCif(unsigned int nargs, ffi_type* rtype, ffi_type** atypes);
+
+    std::vector<const ffi_type*> signatureVector;
 
 protected:
     FFICall(JSC::VM& vm, JSC::Structure* structure)
@@ -34,7 +37,7 @@ class FFICall : public JSC::InternalFunction {
 
     ~FFICall();
 
-    ffi_cif* _cif;
+    std::shared_ptr<ffi_cif> _cif;
 
     class Invocation {
         WTF_MAKE_NONCOPYABLE(Invocation)
@@ -145,6 +148,6 @@ class FFICall : public JSC::InternalFunction {
     size_t _argsArrayOffset;
     std::vector<size_t> _argValueOffsets;
 };
-}
+} // namespace NativeScript
 
 #endif /* defined(__NativeScript__FFICall__) */

src/NativeScript/Calling/FFIFunctionCall.mm

@@ -31,4 +31,4 @@
         [invocation.getResult<id>() release];
     }
 }
-}
+}

src/NativeScript/ObjC/Constructor/ObjCConstructorCall.mm

@@ -55,4 +55,4 @@
 
     return true;
 }
-}
+}