Correct but you can tell when an object is destroyed or memory freed.

But sometime, the memory constraints turns into a dangerous bottleneck

that costs 10k€/y

Btw if you need to duplicate the memory anyway use unique_ptr

Hello everyone, could you help me please. I'm trying to execute an existing program rec and pass array of strings arr as an argument. All works as needed, but not always: when I enter only '\n', the execv returns -1 and error 14 Bad address. int main(int argc, char ** argv) { vector<string> vMessage; char ch; string tmps; while (ch != '\n') { ch = getchar(); if ((ch == ' ') || (ch == '\n') && (tmps != "")) { vMessage.push_back(tmps); tmps = ""; } else tmps += ch; } char * arr[] = {"QWE11", "Asd22"}; cerr << endl << execv("rec", arr) << endl; perror(""); } I have no idea, how are variables ch, vMessage, tmps related to the function execv with array arr I initialized in my code. Why does thic error occur only in that case?

Btw if you need to duplicate the memory anyway use unique_ptr

It is not to duplicate that you use shared or GC

It is not to duplicate that you use shared or GC

So you need to synchronize access to the memory anyway?

So you need to synchronize access to the memory anyway?

No, I need not to do that

I need things to be read by multiple threads a lot

and eventually disposed

if and only if no thread is gonna receive them later

However I don't see how this is not possible using unique_ptr Let the memory owning thread store it in a vector. Pass const pointers to the reading threads. Once you notice no thread is going to receive it and you want to free the memory relaese it from the vector

However I don't see how this is not possible using unique_ptr Let the memory owning thread store it in a vector. Pass const pointers to the reading threads. Once you notice no thread is going to receive it and you want to free the memory relaese it from the vector

because this means it is required to have an owning thread

aka, not concurrent

just parallel

Where does the memory come from?

Where does the memory come from?

network buffers

Some thread (aka owning thread) musr allocate it

Some thread (aka owning thread) musr allocate it

Yeah, and that thread cannot just hang in wait for the +42 other threads to say they are done

The "owning thread" have more requests to accept

Yeah of course, While running: Allocate memory put in in vector pass pointer around

Yeah of course, While running: Allocate memory put in in vector pass pointer around

yeah, and then you get a wonderful mess of who is gonna destroy

knowing that you don't know which thread is gonna be done last

But how can GC be faster than shared_ptr?

You need to synchronize anyhow

But how can GC be faster than shared_ptr?

not relying on atomics and memory fences

How does the GC algorithm work?

and running the least frequently possible

How does the GC algorithm work?

managing a memory tree from the stacks and parallel mark and sweep

and generational management

so marking is done in parallel?

yes

does the same apply for sweeping?

does the same apply for sweeping?

I do not remember, tried to check but it is not explicitly stated

libgc is as fast as glibc malloc

because there might be an issue if it is in parallel: how to prevent duplicate deallocation? if not: How to share state between marking and sweeping? (need synchroniziation)

libgc is as fast as glibc malloc

Use custom memory pools, they are as fast as you want them

because there might be an issue if it is in parallel: how to prevent duplicate deallocation? if not: How to share state between marking and sweeping? (need synchroniziation)

maiking arenas like anywhere else lol

Use custom memory pools, they are as fast as you want them

but don't free buffers

but don't free buffers

Its enough to destruct the object. If desired you can manage the buffer on your own

You know, I don't care about your opinion, GC got me from 12k req/s/core to 22k req/s/core

compared to shared ptr implementation

it's not about opinions, at laest for me - i just want to understand it

copy implementation is out of the question when you allocate 16MB buffers

Granted, GC has advantages and disadvantages

copy implementation is out of the question when you allocate 16MB buffers

agree

and shared_ptr leaded to tons of memory fences that blocked the CPU cache for long nanoseconds regularly

"A mark-sweep garbage collector traverses all reachable objects in the heap by following pointers beginning with the "roots"" I fail to see how this can be faster than an atomic increment, decrement and comparison Traversing chains of pointers additionally tends to introduce several cache misses

"A mark-sweep garbage collector traverses all reachable objects in the heap by following pointers beginning with the "roots"" I fail to see how this can be faster than an atomic increment, decrement and comparison Traversing chains of pointers additionally tends to introduce several cache misses

induces cache misses, uses malloc (and so mmap and cie) for every buffer

and GC needs to synchronize anyhow

and GC needs to synchronize anyhow

only for M&S

and it can perform partial M&S when it can

It mostly has to go with the use

and for both reusing memory and allocating lots of big buffers, GC was the best choice

This application doesn't happen to be Open Source?

I could have used memory pools and a custom allocator to make shared_ptrs in them and implemented my own arena memory management system

This application doesn't happen to be Open Source?

It doesn't

I sell it

I agree passing several shared_ptr around is not ideal.. But i bet there will be a faster method than using GC

It is a distributed database for trading systems

It is a distributed database for trading systems

all trading systems i am aware of forbid the use of GC

all trading systems i am aware of forbid the use of GC

The GC is only used by the network layer that parses data in concurent way to then let it be handled by the storage layer

It is not a quotation engine that should ensure fair transactions, it is closer to MT4 for example

It should ensure valid transactions

well, in fact it could be used as a standalone database

Hi

People

I am just too lazy to add a real n-tree to it

Hello

Hi

Can you creating any game

I am just too lazy to add a real n-tree to it

the gc library you linked uses atomics as well (at least when run in parallel)

the gc library you linked uses atomics as well (at least when run in parallel)

yeah, for the M&S only

which runs less often than the rest and uses FAR less data than the buffers

The things is with big data, shared ptrs fences force to load more pages to the CPU cache

which slow it bucks by bucks

I got curious, I might try to run a benchmark on it in the next couple of days and try to beat the performance G2g now, thanks for the discussion

and replace it with data you will or not use

I got curious, I might try to run a benchmark on it in the next couple of days and try to beat the performance G2g now, thanks for the discussion

Np, have fun :)

Can you creating any game

I would not say any

you can only achieve achievable things