使用 Node 和 Node-gyp 在 AWS Lambda 上出现奇怪的“记忆”行为

Question

我有一个用 NodeJS 编写的 AWS Lambda，调用过程非常简单

NODEJS -> NodeModule(CPP) -> Extern C Function，这个设置是用 node-gyp 编译的。 你可以在https://drive.google.com/open?id=0B-2d-CuY5fkwS3lwdE96R1V6NEk看到完整的代码

CPP 节点模块调用 C 中的一个函数，该函数运行一个循环。并增加两个变量，一个在 C 函数的范围内，另一个在 C 代码的主范围内。

当您在本地运行此代码时。循环递增，两个变量都达到 11，正如预期的那样，你运​​行了多少。但是，当您在 AWS Lambda 中运行相同的代码时，每次调用都会有某种“内存”。并且一般范围内没有被重置的变量正在增加，是 11、22、33 等的倍数。

重复一遍，这永远不会在本地发生，两个变量始终为 11。 你可以通过运行构建 1. node-gyp clean 配置构建 2. node app.js（用于本地运行）

Index.js 用于 AWS Lambda

我真的无法解释这种行为？ Lambda 是否有某种上下文或某种“内存”或缓存？

我已经为此创建了一个开放 API 网关。 （随时刷新并查看正在运行的“记忆”）。

https://koj2yva6z9.execute-api.us-east-1.amazonaws.com/dev/testLambdaCache

这种行为有时不一致，有时计数会重置。或者您可以通过上传新的 AWS lambda 代码来重置。

感谢您对这种奇怪行为的任何想法。

app.js（用于本地测试）

var addon = require('./build/Release/addon');
console.log(addon.testCache());
console.log(" addon method completed");

index.js（用于 lambda）

console.log('Loading function');

exports.handler = (event, context, callback) => {

    var addon = require('./build/Release/addon');
    var returnvalue=addon.testCache();
    console.log(returnvalue);
    console.log(" addon method completed");
    callback(null, "success::"+returnvalue);
}

base.cc（C 代码的包装器）

#include <node.h>
#include <iostream>
#include <stdlib.h>
#include<string>
#include<cstring>

using namespace std;

extern "C" char* testCache();

namespace demo {

    using v8::FunctionCallbackInfo;
    using v8::HandleScope;
    using v8::Isolate;
    using v8::Local;
    using v8::Object;
    using v8::String;
    using v8::Value;
    using v8::Exception;

    void Method(const FunctionCallbackInfo<Value>& args) {
        Isolate* isolate = args.GetIsolate();
        cout << "C++ method started\n";
        char *returnStrings=NULL;
        returnStrings= testCache();
        args.GetReturnValue().Set(String::NewFromUtf8(isolate,  returnStrings ));
    }

    void init(Local<Object> exports) {
        NODE_SET_METHOD(exports, "testCache", Method);
    }

    NODE_MODULE(addon, init)

}  

decoder.c（运行循环的c代码）

int tmpCounter=0;


char* testCache()
{
    int counter=0;
    printf("Local counter --> %d  Global Counter --> %d\n",counter,tmpCounter); 
    for(int i=0;i <10; i++)
    {
        counter = counter +1;
        tmpCounter = tmpCounter +1;
        //sleep(1);
    }
    printf("Local counter --> %d  Global Counter --> %d\n",counter,tmpCounter); 

    counter=counter+1;
    tmpCounter=tmpCounter+1;

    char strCounter[100];
    char strTmpCounter[100];
    snprintf(strCounter, 16, "%d", counter);

    snprintf(strTmpCounter, 16, "%d", tmpCounter);

    char *returnString=NULL;
    returnString=malloc(1000);

    strcat(returnString, "Count:");
    strcat(returnString, strCounter);
    strcat(returnString, " TmpCount:");
    strcat(returnString, strTmpCounter);
    strcat(returnString, "\0");
    printf("%s\n",returnString);
    fflush(stdout);
    return returnString;

}

Answer 1

Lambda 是否提供某种上下文或某种“内存”或缓存？

我不会说它是“可用的”，因为它是可预测的或一致的，因为您不应该围绕它进行设计，但是是的，存在容器重用。

查看实际效果：

创建一个 uuid，或随机数，或类似的东西，并将其存储在处理程序外部的全局变量中。然后，在处理程序内部，记录它。您会看到相同的进程或进程组（由 uuid 标识）可能但不一定会处理时间上接近的后续请求。

假设你的函数完成了，一段时间过去了，然后你再次调用它。 Lambda 可能会重新创建一个新容器 [...]

但是，如果您没有更改代码并且没有经过太多时间，Lambda 可能会重用以前的容器。这为双方提供了一些性能优势：Lambda 可以跳过 nodejs 语言初始化，而您可以跳过代码中的初始化。如果沙盒被重用，您上次写入 /tmp 的文件仍然存在。

https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/

Answer 2

所有对strcat 到testCache 的调用都是UB，因为mallocated 内存未启动。

使用calloc更改它

returnString=calloc(1, 1000);

或将第一个更改为sprintf

sprintf(returnString, "Count:");

而且strcat(returnString, "\0");没用

最后总是检查 malloc 和朋友返回值，例如

if (returnString != NULL)
{
   // OK, MEMORY ALLOCATED
}
else
{
   // ERROR
}