expose-gc | Expose gc without passing the arg param | Game Engine library

Garbage collection can collect something and recycle its memory ONLY when there is no other code that can reach or use or reference that variable. Sometimes that situation occurs when a function declares a local variable and then the function executes and returns, but not always.

If there are asynchronous operations running (and your child process is an asynchronous operation) and event handlers or callbacks declared within that function scope and those callbacks/events could still be called, then the reachable variables in that function scope cannot be garbage collected until they are truly not reachable any more which, in your case, may be long, long after the function has already executed and returned because that lifetime is associated with the lifetime of the child process, not with the lifetime of the function execution.

In your specific case, because the child object can still emit events long after the function has returned, then then that child object and anything else that its event handlers may access cannot be garbage collected until the child object itself is GCed or until some other situation tells the garbage collector that that event handler can't be called any more.

So, keep in mind that in Javascript, local variables in a function do not go into a strict stack frame that is 100% recycled as soon as the function returns. Instead, they are properties on a scope object and each individual property on that scope object can only be garbage collected when it is no longer reachable by any active code. So, it's possible for some things in a scope object to get garbage collected because they aren't referenced in any code that can still be called while other things on the scope object cannot yet be garbage collected because there are callbacks declared within that function scope that may still reference some of those variables declared within that function. The same rules apply to either a function-scoped or a block-scoped variable as a function scope is just a larger block than a block scope - they now work pretty much the same.

Here's a fairly simple example:

As per the official documentation, you need to have something like this S3Options

AWS credentials are required, please see getting your credentials. Define AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables. Or in the ~/.aws/credentials.

This is a problem with react-table v7.0.1, upgrading to v7.0.2 fixes the problem.

It's a minification bug. Here is the exact commit that fixed the problem.

From the Changelog :

7.0.2

• Fixed an issue where the internal flexRenderer would not work correctly in production due to the strangest friggin' minification bug I've ever encountered. 🤷‍♂️

I've got the answer directly from @jasnell:

You could try the natives syntax function %CollectGarbage

I've tried it, and it worked exactly how I wanted. In real life, it's a chain of AbortController objects, more context here.

To enable %CollectGarbage:

The root cause of the issue is the weakness of the VM t2.micro.

t2.micro has only 1 vCPU and 1GB memory

I would say that this capacity can be enough for the app runtime (nginx).

But it will never be enough for the app build (npm run build) .

By experience, we are responsible for building more than 400 plans and npm build can take up to 16G memory for some react/angular projects.

If you don't want to spend money in opening bigger VM (instance), this is workaround :

• Build the image(s) in your machine.
• Copy the built images to the ec2 instance.
• Run the images in the ec2 instance.

in your laptop

You have only declared the WebDriver instance as:

Thanks for @jfriend00 's comment, it really helped me to narrow this down.

So asyncawait and its underlying node-fibers turn out to be the root cause in my case.

While I'm still not quite sure how this is happening (as this is a widely used module and doesn't seem to find anyone talking about this). But taking some time replacing all asyncawait with node native async brings the thread count back to 4.

You need to declare the WebDriver instance and add the constructor in LoginPageElements & LoginPageActions class as:

1. LoginPageElements class:

When you attach an on listener, the listener stays active until you remove it with off. While the listener is active, Firebase will keep an in-memory copy of all data that the listener receives. The memory usage of this in-memory copy/cache can be quite significant, so you should remove your listeners when you don't need the data anymore.

To remove all listeners on a reference: