atomic | Trying microservices | Continuous Deployment library
kandi X-RAY | atomic Summary
kandi X-RAY | atomic Summary
This is a simple POC that shows how build an polyglot microservices based infrastructure with docker and kubernetes. The name atomic stands for: little apps (atoms) working together without matters his language. And follows the UNIX philosophy: " The Unix philosophy emphasizes building simple, short, clear, modular, and extensible code that can be easily maintained and repurposed by developers other than its creators. The Unix philosophy favors composability as opposed to monolithic design." according wikipedia or "do one thing and do it well".
Support
Quality
Security
License
Reuse
Top functions reviewed by kandi - BETA
- Shortcut for testing .
atomic Key Features
atomic Examples and Code Snippets
Community Discussions
Trending Discussions on atomic
QUESTION
When I see this CPP Con 2017 webinar, Fedor Pikus says: "it has to be direct initialization"
This is the link to the webinar.
What are the differences between these initialization methods? (and subsequently, why it has to be a "direct" initialization? why "indirect" initialization is "NOT"?)
...ANSWER
Answered 2022-Apr-10 at 16:06std::atomic
is not copyable or movable.
Before C++17, the copy-initialization std::atomic x = 0;
would first construct a temporary std::atomic
from 0
and then direct-initialize x
from that temporary. Without a move or copy constructor this would fail and so the line doesn't compile.
std::atomic x(0);
however is direct-initialization and will just construct x
with the argument 0
to the constructor.
Since C++17 there is no temporary and x
will directly be initialized by a constructor call with 0
as argument in any case and so there is no issue with std::atomic
being non-movable. In that sense the slide is now out-dated.
Even though the behavior is now the same for copy-initialization and direct-initialization in this case, there are still differences between the two in general. In particular direct-initialization chooses a constructor to initialize the variable directly by overload resolution while copy-initialization tries to find an implicit conversion sequence (possibly via converting constructor or conversion function with different overload resolution rules). Also, copy-initialization, in contrast to direct-initialization, does not consider constructors marked explicit
.
Regarding the code snippet in the question. 1-h
and 1-f
are copy-initialization as above. 3-f
is direct-initialization as above. 2-h
and 2-f
are direct-list-initialization, which behaves different from both others in some cases, but here it has the same effect as direct-initialization with parentheses.
Explaining all the differences between the initialization forms in general would take a while. This is famously one of the most complex parts of C++.
QUESTION
I stumbled upon a strange compile error in Clang-12. The code below compiles just fine in GCC 9. Is this a bug in the compiler or is there an actual problem with my code and GCC is just too forgiving?
...ANSWER
Answered 2022-Mar-19 at 11:22Looks like a bug to me. Modifying case A
to case nullptr
gives the following error message (on the template definition):
QUESTION
I am trying to show only the first two rows of a CSS GRID.
The width of the container is unknown therefore it should be responsive.
Also the content of each box is unknown.
My current hacky solution is to define the following two rules:
- use an automatic height for the first two rows
- set the height of the next 277 rows to 0 height
grid-auto-rows: auto auto 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
I tried repeat() like this: grid-auto-rows: auto auto repeat(277, 0px)
but unfortunately it didn't set the height to 0.
Is there any clean way to repeat height 0?
...ANSWER
Answered 2022-Feb-07 at 21:16Define a template for the two rows and then use grid-auto-rows
with 0
QUESTION
Starting C++20, std::atomic
has wait()
and notify_one()
/notify_all()
operations. But I didn't get exactly how they are supposed to work. cppreference says:
Performs atomic waiting operations. Behaves as if it repeatedly performs the following steps:
- Compare the value representation of this->load(order) with that of old.
- If those are equal, then blocks until
*this
is notified by notify_one() or notify_all(), or the thread is unblocked spuriously.- Otherwise, returns.
These functions are guaranteed to return only if value has changed, even if underlying implementation unblocks spuriously.
I don't exactly get how these 2 parts are related to each other. Does it mean that if the value if not changed, then the function does not return even if I use notify_one()
/notify_all()
method? meaning that the operation is somehow equal to following pseudocode?
ANSWER
Answered 2022-Jan-24 at 07:38Yes, that is exactly it. notify_one/all simply provide the waiting thread a chance to check the value for change. If it remains the same, e.g. because a different thread has set the value back to its original value, the thread will remain blocking.
Note: A valid implementation for this code is to use a global array of mutexes and condition_variables. atomic variables are then mapped to these objects by their pointer via a hash function. That's why you get spurious wakeups. Some atomics share the same condition_variable.
Something like this:
QUESTION
I have a list of data in a visualisation and I want to make it as accessible as possible. There are two lists next to each other.
The list items has two states. Multiple rows can be active or inactive. A single row could be selected.
Selecting something in one list, will show 'related' items as active, and inactive. See the simplified example below. The user has selected "A 2", which is linked to "B 1" and "B 4", so A2 is aria-selected
but there's no aria-active
or aria-inactive
, I thought to use aria-disabled
as demonstrated - BUT does this not indicate that it is not interactable? The user can still click on the disabled item to then select it.
Would it be better to do multiple aria-selected
, and a single aria-current=true
on the single 'selected' item? Would it be odd that if the user hasn't yet made a selection and everything is 'active', every item will be aria-selected=true
?
ANSWER
Answered 2022-Jan-14 at 23:31From a semantics and accessibility point of view, I'd consider separating out the controls from the visualization itself—at least in terms of the markup. This will let you use more semantic input elements, like , which come with their own states that assistive tech understands. And it will keep selection state (which is an input element trait) separate from highlighted state (which is a visualization display trait).
You can then tie those input elements to the visualization using the aria-controls
attribute.
To denote the state of the items in the visualization itself, instead of using ARIA roles, I would suggest just using text.
A basic example could work something like this:
QUESTION
Constraints in C++20 are normalized before checked for satisfaction by dividing them on atomic constraints. For example, the constraint E = E1 || E2
has two atomic constrains E1
and E2
And substitution failure in an atomic constraint shall be considered as false value of the atomic constraint.
If we consider a sample program, there concept Complete = sizeof(T)>0
checks for the class T
being defined:
ANSWER
Answered 2022-Jan-07 at 15:39This is Clang bug #49513; the situation and analysis is similar to this answer.
sizeof(T)>0
is an atomic constraint, so [temp.constr.atomic]/3 applies:
To determine if an atomic constraint is satisfied, the parameter mapping and template arguments are first substituted into its expression. If substitution results in an invalid type or expression, the constraint is not satisfied. [...]
sizeof(void)>0
is an invalid expression, so that constraint is not satisfied, and constraint evaluation proceeds to sizeof(U)>0
.
As in the linked question, an alternative workaround is to use "requires requires requires"; demo:
QUESTION
I was able to build a multiarch image successfully from an M1 Macbook which is arm64. Here's my docker file and trying to run from a raspberrypi aarch64/arm64 and I am getting this error when running the image: standard_init_linux.go:228: exec user process caused: exec format error
Editing the post with the python file as well:
...ANSWER
Answered 2021-Oct-27 at 16:58A "multiarch" Python interpreter built on MacOS is intended to target MacOS-on-Intel and MacOS-on-Apple's-arm64.
There is absolutely no binary compatibility with Linux-on-Apple's-arm64, or with Linux-on-aarch64. You can't run MacOS executables on Linux, no matter if the architecture matches or not.
QUESTION
I'm trying to understand the purpose of std::atomic_thread_fence(std::memory_order_seq_cst);
fences, and how they're different from acq_rel
fences.
So far my understanding is that the only difference is that seq-cst fences affect the global order of seq-cst operations ([atomics.order]/4
). And said order can only be observed if you actually perform seq-cst loads.
So I'm thinking that if I have no seq-cst loads, then I can replace all my seq-cst fences with acq-rel fences without changing the behavior. Is that correct?
And if that's correct, why am I seeing code like this "implementation Dekker's algorithm with Fences", that uses seq-cst fences, while keeping all atomic reads/writes relaxed? Here's the code from that blog post:
...ANSWER
Answered 2022-Jan-06 at 05:14As I understand it, they're not the same, and a counterexample is below. I believe the error in your logic is here:
And said order can only be observed if you actually perform seq-cst loads.
I don't think that's true. In atomics.order p4 which defines the
axioms of the sequential consistency total order S, items 2-4 all may
involve operations which are not seq_cst
. You can observe the
coherence ordering between such operations, and this can let you infer
how the seq_cst
operations have been ordered.
As an example, consider the following version of the StoreLoad litmus test, akin to Peterson's algorithm:
QUESTION
I have a ring buffer that looks like:
...ANSWER
Answered 2021-Dec-31 at 12:49Previous answers may help as background:
c++, std::atomic, what is std::memory_order and how to use them?
https://bartoszmilewski.com/2008/12/01/c-atomics-and-memory-ordering/
Firstly the system you describe is known as a Single Producer - Single Consumer queue. You can always look at the boost version of this container to compare. I often will examine boost code, even when I work in situations where boost is not allowed. This is because examining and understanding a stable solution will give you insights into problems you may encounter (why did they do it that way? Oh, I see it - etc). Given your design, and having written many similar containers I will say that your design has to be careful about distinguishing empty from full. If you use a classic {begin,end} pair, you hit the problem that due to wrapping
{begin, begin+size} == {begin, begin} == empty
Okay, so back synchronisation issue.
Given that the order only effects reording, the use of release in Publish seems a textbook use of the flag. Nothing will read the value until the size of the container is incremented, so you don't care if the orders of writes of the value itself happen in a random order, you only care that the value must be fully written before the count is increased. So I would concur, you are correctly using the flag in the Publish function.
I did question whether the "release" was required in the Consume, but if you are moving out of the queue, and those moves are side-effecting, it may be required. I would say that if you are after raw speed, then it may be worth making a second version, that is specialised for trivial objects, that uses relaxed order for incrementing the head.
You might also consider inplace new/delete as you push/pop. Whilst most moves will leave an object in an empty state, the standard only requires that it is left in a valid state after a move. explicitly deleting the object after the move may save you from obscure bugs later.
You could argue that the two atomic loads in consume could be memory_order_consume. This relaxes the constraints to say "I don't care what order they are loaded, as long as they are both loaded by the time they are used". Although I doubt in practice it produces any gain. I am also nervous about this suggestion because when I look at the boost version it is remarkably close to what you have. https://www.boost.org/doc/libs/1_66_0/boost/lockfree/spsc_queue.hpp
QUESTION
Herb Sutter, in his "atomic<> weapons" talk, shows several example uses of atomics, and one of them boils down to following: (video link, timestamped)
A main thread launches several worker threads.
Workers check the stop flag:
...
ANSWER
Answered 2022-Jan-05 at 14:48mo_relaxed
is fine for both load and store of a stop
flag
There's also no meaningful latency benefit to stronger memory orders, even if latency of seeing a change to a keep_running
or exit_now
flag was important.
IDK why Herb thinks stop.store
shouldn't be relaxed; in his talk, his slides have a comment that says // not relaxed
on the assignment, but he doesn't say anything about the store side before moving on to "is it worth it".
Of course, the load runs inside the worker loop, but the store runs only once, and Herb really likes to recommend sticking with SC unless you have a performance reason that truly justifies using something else. I hope that wasn't his only reason; I find that unhelpful when trying to understand what memory order would actually be necessary and why. But anyway, I think either that or a mistake on his part.
The ISO C++ standard doesn't say anything about how soon stores become visible or what might influence that, just Section 6.9.2.3 Forward progress
18. An implementation should ensure that the last value (in modification order) assigned by an atomic or synchronization operation will become visible to all other threads in a finite period of time.
Another thread can loop arbitrarily many times before its load actually sees this store value, even if they're both seq_cst
, assuming there's no other synchronization of any kind between them. Low inter-thread latency is a performance issue, not correctness / formal guarantee.
And non-infinite inter-thread latency is apparently only a "should" QOI (quality of implementation) issue. :P Nothing in the standard suggests that seq_cst
would help on an implementation where store visibility could be delayed indefinitely, although one might guess that could be the case, e.g. on a hypothetical implementation with explicit cache flushes instead of cache coherency. (Although such an implementation is probably not practically usable in terms of performance with CPUs anything like what we have now; every release and/or acquire operation would have to flush the whole cache.)
On real hardware (which uses some form of MESI cache coherency), different memory orders for store or load don't make stores visible sooner in real time, they just control whether later operations can become globally visible while still waiting for the store to commit from the store buffer to L1d cache. (After invalidating any other copies of the line.)
Stronger orders, and barriers, don't make things happen sooner in an absolute sense, they just delay other things until they're allowed to happen relative to the store or load. (This is the case on all real-world CPUs AFAIK; they always try to make stores visible to other cores ASAP anyway, so the store buffer doesn't fill up, and
See also (my similar answers on):
- Does hardware memory barrier make visibility of atomic operations faster in addition to providing necessary guarantees?
- If I don't use fences, how long could it take a core to see another core's writes?
- memory_order_relaxed and visibility
- Thread synchronization: How to guarantee visibility of writes (it's a non-issue on current real hardware)
The second Q&A is about x86 where commit from the store buffer to L1d cache is in program order. That limits how far past a cache-miss store execution can get, and also any possible benefit of putting a release or seq_cst fence after the store to prevent later stores (and loads) from maybe competing for resources. (x86 microarchitectures will do RFO (read for ownership) before stores reach the head of the store buffer, and plain loads normally compete for resources to track RFOs we're waiting for a response to.) But these effects are extremely minor in terms of something like exiting another thread; only very small scale reordering.
because who cares if the thread stops with a slightly bigger delay.
More like, who cares if the thread gets more work done by not making loads/stores after the load wait for the check to complete. (Of course, this work will get discarded if it's in the shadow of a a mis-speculated branch on the load result when we eventually load true
.) The cost of rolling back to a consistent state after a branch mispredict is more or less independent of how much already-executed work had happened beyond the mispredicted branch. And it's a stop
flag so the total amount of wasted work costing cache/memory bandwidth for other CPUs is pretty minimal.
That phrasing makes it sound like an acquire
load or release
store would actually get the the store seen sooner in absolute real time, rather than just relative to other code in this thread. (Which is not the case).
The benefit is more instruction-level and memory-level parallelism across loop iterations when the load produces a false
. And simply avoiding running extra instructions on ISAs where an acquire or especially an SC load needs extra instructions, especially expensive 2-way barrier instructions, not like ARM64 ldapr
.
BTW, Herb is right that the dirty
flag can also be relaxed
, only because of the thread.join
sync between the reader and any possible writer. Otherwise yeah, release / acquire.
But in this case, dirty
only needs to be atomic<>
at all because of possible simultaneous writers all storing the same value, which ISO C++ still deems data-race UB. e.g. because of the theoretical possibility of hardware race-detection that traps on conflicting non-atomic accesses.
Community Discussions, Code Snippets contain sources that include Stack Exchange Network
Vulnerabilities
No vulnerabilities reported
Install atomic
You can use atomic like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the atomic component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .
Support
Reuse Trending Solutions
Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from over 650 million Knowledge Items
Find more librariesStay Updated
Subscribe to our newsletter for trending solutions and developer bootcamps
Share this Page