p99 | function definitions that ease the programming in modern C | Script Programming library

You should do all before exporting. Something like this:

//Here I had in first answer code with generating xml document, but you need just to export it to csv. My bad.

You can do this:

This code is if you want to have more control over it and add some other things like checking values and etc...

*Solution with select-string

You can use base split and lapply function to get desired results.

I worked through the question based on two examples. The first was my older daughter which was initially quite long/tall.

Girl Age 49 days, 60 cm divide by 30.4375 = 1.61 months

So that's between month 1 and month 2:

part_cols in the question is an array of rows. So the first step is to convert it into an array of strings.

For your reference.

The answer I hope woule be show the count of people have car in same area.

You can use aggregation:

According to Triggering of gc on Metaspace memory in java 8, the full GC is needed in order to reduce metaspace usage.

My understanding is that metaspace is not garbage collected per se. Instead, you have objects in the ordinary heap that hold special references to metaspace objects. When the objects are collected by the GC, the corresponding metaspace objects are freed. (Conceptually it is like finalization where the finalizer is free-ing the metaspace objects.)

When it reach this first high-water-mark should not it make it bigger next time until the max size?

Apparently not. The normal strategy for HotSpot collectors is like this:

1. allocate objects until you hit the current heap limit
2. run the collector
3. look at how much space was reclaimed, and increase (or decrease) the heap size if warranted.

It seems that the same strategy is used here. And the full GC is causing enough metaspace to be reclaimed that it decides that it doesn't need to expand metaspace.

A band-aid for this would be to try setting -XX:MetaspaceSize and -XX:MaxMetaspaceSize to the same value, but that will just make the full GCs less frequent.

A real solution would be to figure out what is consuming the metaspace, and fix it.

Answering my own question with some help from the Pyro forums. The code below contains the solution to the first half of the problem, finding a distribution that matches the parameters from the collected quantiles:

According to your description, your change included two unrelated parts: You compressed the payload, and increased the number of items per partition. The first change - the compression - probably has little effect on the p99 latency (it could have a more noticable effect on the mean latency - which, according to Little's Law is related to throughput, if your client has fixed concurrency - but I'd expect it to lower, not increase).

Some guesses as to what might have increased the p99 latency:

1. More items per partition means that DynamoDB (which uses a B-tree) needs to do more disk reads to find a specific item. Since each disk access has rare delays caused by queueing, this adds to the tail latency.

2. You said that the change caused each partition to hold more items, I guess this means you now have fewer partitions. If you have too few of them, you can start getting unbalanced load on the different DynamoDB partitions, and more contention and latency for specific "hot" partitions.

3. I don't know how you measure your latency. Your client now needs (I guess) to uncompress the returned result, maybe it is now busier, adding queening delays in the client? Can you lower your client's concurrency (how many client threads run in parallel) and see if the high tail latency is an artifact of the server design, or the client's design?