Hoard | Hoard Memory Allocator : A Fast Scalable

I have managed parallel run my task below:

I am working with a very special dataframe in R that has some variables defined as lists. My dataframe df is included at the end of the post with dput(). The issue with this dataframe is that holds lists as variables:

In the source of geometricsizeclass.cpp of Hoard (the memory allocator) there a not defined function bool c2s(int).

What is it, what does it do ?

I'm trying to compile hoard as a library in VS2019, ignoring the Makefile.

I am attempting to use python to pull down a zone file. After going through hoards of documentation, I am still stuck on one line of code:

dns.zone.from_xfr(dns.query.xfr('3.211.54.86','megacorpone.com'))

I get the following error:

socket.error: [Errno 111] Connection refused

I've hardcoded ns2.megacorpone.com's IP to isolate any problems. For some reason this connection continues to refuse. Is anyone able to shed some light on this problem?

Thanks all

We are using Google PubSub in a 'spiky' fashion where we publish millions of small messages (< 10k) in a short time (~ 10 mins), spin up 2k GKE pods with 10 worker threads each that use synchronous pull and acknowledge PubSub service calls to work through the associated subscription (with a 10 minute acknowledgement deadline). The Stack Driver graph for the subscription backlog will show a spike to 10M messages and then a downward slope to 0 in around 30 minutes (see below).
We noticed an increase of message re-delivery as the size of these backlogs grew from 1M to 10M from below 1% to beyond 10% for certain hours.

Coming from the GAE Task Pull queue world, we assumed that a worker would "lease" a message by pulling a message from the PubSub subscription where, starting at the time of pull, a worker would have 10 minutes to acknowledge to message. What appears to be happening however, after adding logging (see below for example of a re-published message), is that it is not the time from pull to ack that matters, but the time from publishing the message to acknowledgement.

Is this the right understanding of PubSub acknowledgement deadline, and subsequent redelivery behavior?

If so, should we be making sure the subscription's message backlog should only grow to a size that worker threads are able to process and acknowledge within the time configured for the subscription's acknowledgement deadline to get re-delivery rates to < 0.1% on average? We can probably have the publisher apply some sort of back-pressure based on the subscription backlog size although the GAE Pull Task Queue leasing behavior seems more intuitive.

Also, the wording in https://cloud.google.com/pubsub/docs/subscriber#push-subscription, under "Pull subscription": "The subscribing application explicitly calls the pull method, which requests messages for delivery" seems to imply that the acknowledgment timeout starts after the client pull call returns a given message?

Note: we use the Python PubSub API (google-cloud-pubsub), although not the default streaming behavior as this caused "message hoarding" as described in the PubSub docs given the large amount of small messages we publish. Instead we call subscriber_client.pull and acknowledge (which seems thin wrappers around the PubSub service API calls)

I'm trying to find a way to have enemies track the player in my 2d game (pygame) but not clump up

Currently, when I shoot at them, the bullet collides into and damages all of the enemies that are clumped. I would like it to be a hoard but spread out just enough to where I can't hit every single enemy at once

It looks like this

Here's a gif of them clumping

I'm not sure how I would get the individual values of the enemies' positions so I can move them when they collide or how I should move them

This is what I currently have for the enemies to track the player:

For a Discord bot, I currently have a command that displays info for our DnD sessions:

.

The data is stored in a dndinfo.json file thats looks like this: