Does C have a future ?

It doesn't have a condition variable either :D

because each camera is on different threads

And? condition_variable is thread safe, it is a synchronization system

each camera has to finish in order for me to move to the next step in the algorithm

And? condition_variable is thread safe, it is a synchronization system

however i could do it with 6 condition variables

or just one which is a semaphore

because each camera is on different threads

Would it be enough to have only one thread per each camera?

however i could do it with 6 condition variables

or just one which is an int, with computation going on when it gets equal to 6

Would it be enough to have only one thread per each camera?

well actually each one has 2 threads

or just one which is an int, with computation going on when it gets equal to 6

which is what a semaphore is

well actually each one has 2 threads

It must have like... a thread per a stream or so

which is what a semaphore is

Exactly, making C++ have semaphores

no it does not have easy ones

So they don't get the name, but are here

and relies on g++ implementing all operations on ints as atomic ones

or me to use volatile

which is a bad programming practice because it lowers the optimizations around that variable

or me to use volatile

volatiles are not atomic

volatiles are not atomic

N E V E R

volatiles are not atomic

they are for a real time operating system purpose

it is used a LOT in embedded systems especially with real time oses

they are for a real time operating system purpose

They never are

Unless you have a single thread

Unless you have a single thread

Where everything is atomic? :D

Where everything is atomic? :D

exactly

Is that LGBT flag?

You can consider volatile to work like atomic IF AND ONLY IF a single thread writes to the variable

it is used a LOT in embedded systems especially with real time oses

But not for atomic operations

But not for atomic operations

actually it is

You can consider volatile to work like atomic IF AND ONLY IF a single thread writes to the variable

Then you wouldn't need it 😢

because for those systems we require basic operations to be atomic

like ints

and so on

Volatile does not make them atomic

Unless you have a single thread

or you are using atomic datastructures like ints

for gcc

because for those systems we require basic operations to be atomic

volatile do not make anything atomic, they make things updated on time of use

because for those systems we require basic operations to be atomic

Yah, and your code would be platform dependent

or you are using atomic datastructures like ints

N O

atomic instructions use completely different CPU instructions

or you are using atomic datastructures like ints

ints are not atomic

ints are not atomic

True, nothing is UNLESS SPECIFIED OTHERWISE

I am atomic ^-^

Yah, and your code would be platform dependent

you are working on embedded systems you kindof need to

atomic instructions use completely different CPU instructions

yes however if an instruction takes one clock cycle

it is pretty much completely atomic to execute that instruction

yes however if an instruction takes one clock cycle

and adding something to a point in RAM takes 2, like any operation over memory out of registers

you are working on embedded systems you kindof need to

If you want to reuse your code, you want to make platform dependent parts as small as you can. You don't want all of your software to be platform dependent

and adding something to a point in RAM takes 2, like any operation over memory out of registers

no you just keep it in a register

no you just keep it in a register

You don't if it is volatile

if you use the register keyword you do

furthermore, the CPU pipeline may take up to 5 instructions to propagate a volatile change in memory

if you use the register keyword you do

then it is not a volatile

You don't if it is volatile

Are volatiles cached in a processor?

then it is not a volatile

volatile just means it is able to be changed at any time

volatile just means it is able to be changed at any time

Which is NOT atomic

Are volatiles cached in a processor?

exactly not

for basic things like ints it is close enough to atomic that it is considered as cheap atomic variables

Register volatiles, anyone? ^^

if two threads increment a volatile near the same time, only one increment may happen

Register volatiles, anyone? ^^

means the variable is in register and cannot be optimized away or anything

Aka lost update

if two threads increment a volatile near the same time, only one increment may happen

never had this occur

Aka lost update

exactly, this is why we use test_and_set operations

which are TRULY atomic

can you give me an example of this

never had this occur

That's what makes debugging so fun, actually

That's what makes debugging so fun, actually

oh i had one programmer who sent a double pointer to memcpy

and i was wondering why the fuck did the code not work

when i saw that & to the pointer thing i almost shot myself

that guy worked in the field for 20 fucking years

I'm not sure what I like more. Having a double pointer or passing it to memcpy :D

THERE IS A REASON I MAKE PEOPLE DO FUCKING UNIT TESTS BEFORE PUSHING THEIR FUCKING CODE

Do you have unit tests on embedded systems?

i try to get them to

but it is hard

because they just do not want to FUCKING WRITE UNIT TESTS

Yeah, most people I know who do embedded

Don't use unit tests

i am not even making them do boost unit tests