ReaDB | ReaDB is your private digital bookshelf | Web Framework library

Q: "How can I build the inventory file?"

A: This is the YAML version of the inventory. I've added the variable queues to make it a valid YAML

Please try below program. This program first reads filea and creates a dictionary of style and lines, then reads fileb line by line to match and pick style from dictionary, and writes it to filec.

Although the definition for buf_uniqueId is missing, storing to a valid array with at least 12 elements should work OK. Consider readb() possibly returning a zero. Instead of calling strlen() and expecting a NULL-terminated string, the write size should be one of sizeof() or fixed at 12, depending on buf_uniqueId allocation. You might replace each 12 with a #define symbol.

Suggest removing the get_fs() and set_fs() lines, along with replacing vfs_write() with a call to kernel_write() and check the result; also note the old_fs restoration within kernel_write()

The compiler should complain about comparing pointer and integer: (unique == -1); filp_open() could return various error codes; follow the source code from filp_open() to see various error related macros, eg IS_ERR()

The problem might be caused by serial_pow2.DiscardInBuffer().

Unless you know there is no data you need in buffer, don't discard it.

If you make two request and just read one response, serial_pow2.DiscardInBuffer() will discard the second response in buffer.

Since your snippet is initialed by button, I can't assure how do you make request and get response.

My suggestion is not using DiscardInBuffer unless you're initializing or closing your application, or you might lose data.

Not really sure how you get the 3 count for GENEa and READSb, but assuming you want the count, you can try the following:

C++ STL doesn't have a Cyclic Barrier. You may propose one to the standards committee :)

A company like Oracle or Microsoft can quickly decide what to add to their language's library. For C++, people have to come to an agreement, and it can take a while.

256 threads is a lot. As with all performance-related questions, you need to measure the code to make an informed decision. With 256 threads I would be tempted to use 10 barriers that are synchronized by an 11th barrier. You need to measure to know if that's actually better.

Check out my C++ implementation of a cyclic barrier, inspired by Java. I wrote it a couple years ago. It's based it off of someone else's (buggy) code I found at http://studenti.ing.unipi.it/~s470694/a-cyclic-thread-barrier/ (link doesn't work anymore...) The code is really simple (no need to credit me). Of course, it's as is, no warranties.

You need to use pointers to member functions, like this:

Locks do not guarantee sequential consistency. Rather, it guarantees that if a thread starts an operation where it requires a set of resources, no other thread can access (and alter) those resources till the thread with the lock is done with the resources. Which thread attempts to access the resources first is subject to a whole bunch of other factors which the lock doesn't really care about.

Use locks in operations where u want guarantee that an object(s) is not modified by other threads during that operations. Which operation accesses the thread first - thats a whole different story.

See the lock statement documentation.

Following may help you on same.