vtest | assist security engineers in vulnerability mining | Hacking library

You can use lapply and combine the output in one dataframe.

It's not really a matter of "when". Because of the way that m is declared, the two threads have no reason to believe that it needs to consider the value in main memory.

Consider that ++m is not an atomic operation, but is rather:

• A read
• An increment
• A write

Because the thread doesn't know it needs to read from or flush to main memory, there is no guarantee as to how it is executed:

• Perhaps it reads from main memory each time, and flushes to main memory each time
• Perhaps it reads from main memory just once, and doesn't flush to main memory when it writes
• Perhaps it reads from/writes to main memory on some iterations of the loop
• (...many other ways)

So, essentially, the answer is that there is no guarantee that the value is read from or written to main memory, ever.

If you declare m as volatile, that gives you some guarantees: that m is definitely read from main memory, and definitely flushed to main memory. However, because ++m isn't atomic, there is no guarantee that you get 20000 at the end (it's possible it could be 2, at worst), because the work of the two threads can intersperse (e.g. both threads read the same value of m, increment it, and both write back the same value m+1).

To do this correctly, you need to ensure that:

1. ++m is executed atomically
2. The value is guaranteed to be visible.

The easiest way of doing this would be to use an AtomicInteger instead; however, you could mutually synchronize the increments:

From https://source.android.com/setup/develop/64-bit-builds :

LOCAL_MODULE_TARGET_ARCH

Set this variable to a list of architectures, such as arm x86 arm64. If the architecture being built is in that list, the current module is included by the build system.

LOCAL_MODULE_UNSUPPORTED_TARGET_ARCH

This variable is the opposite of LOCAL_MODULE_TARGET_ARCH. If the architecture being built is not in that list, the current module is included by the build system.

Pyinstaller can't detect this import so it doesn't attach it to the bundle. This happens due to less straightforward imports in the libs.

There are more than one solution:

• Anywhere in your code add import statement for every missing module. As adding new module might lead to new missing modules it imports, you might need several iterations.

• Add the same list of modules to hiddenimports argument in spec file or console command. This process might be iterative as well.

Another reason for missing modules is that PyInstaller treats them as system ones, because they are stored in dirs like /usr/lib. You can check if it is your case by importing the module and printing its .__file__.

Here’s a couple of things to try to get the native-zmq parts working:

Use .connect()-method for SUB-sockets : socket.connect("tcp://localhost:6666")

And .bind()-method for your PUB-sockets : socket.bind("tcp://*:6666")

It’s explained here in the guide that connect should be used to create an outgoing connection from a socket.

In the sibling doc for .bind(), it explains that it’s for accepting connections.

Also try setting socket options : socket.setsockopt(zmq.SUBSCRIBE, "")

It is described here in the guide that the SUB-sockets initially filter out all messages, so that’d explain why you’re not receiving anything. The example above provides an empty filter, which accepts all incoming messages.

It’s important to note that with PUB and SUB based distribution, that the SUB might not necessarily receive messages due to timing of its connection or network conditions. E.g. everything sent from the publisher before the subscriber connects isn’t receivable

I figured out how to solve the problem. Long things short, I used CMake to include Google Test in the project.

First, I moved example.cpp and example.h into a new folder called example and created a CMakeLists.txt to compile as a library.

example/CMakeLists.txt:

Mysql can use two algorithms to process a view:

For MERGE, the text of a statement that refers to the view and the view definition are merged such that parts of the view definition replace corresponding parts of the statement.

For TEMPTABLE, the results from the view are retrieved into a temporary table, which then is used to execute the statement.

For UNDEFINED, MySQL chooses which algorithm to use. It prefers MERGE over TEMPTABLE if possible, because MERGE is usually more efficient and because a view cannot be updatable if a temporary table is used.

As per restrictions on views section of mysql manual:

Indexes can be used for views processed using the merge algorithm. However, a view that is processed with the temptable algorithm is unable to take advantage of indexes on its underlying tables (although indexes can be used during generation of the temporary tables).

The select statement used for creating the view contains a group by clause. As per section 8.2.2.4 Optimizing Derived Tables, View References, and Common Table Expressions with Merging or Materialization of the mysql manual:

Constructs that prevent merging are the same for derived tables, common table expressions, and view references:

Aggregate functions or window functions (SUM(), MIN(), MAX(), COUNT(), and so forth)

DISTINCT

GROUP BY

HAVING

LIMIT

UNION or UNION ALL

Subqueries in the select list

Assignments to user variables

Refererences only to literal values (in this case, there is no underlying table)

Because of the group by clause the temptable algorithm is used for the view. This results in mysql materialising the view as a temporary table first without pushing down the filter criteria from the outer query, resulting in the wider scan you see in the explain. The filtering happens on the temporary table and cannot take advantage of the indexes on the underlying tables.

You really need to be aware if mysql uses the merge or temptable approach for a view, since the behaviour of the views will very much depend on this choice.

The code you posted is trying to pass a method by reference. This is not possible in VBA. The closest you can get is the CallByName function

https://docs.microsoft.com/en-us/office/vba/Language/Reference/user-interface-help/callbyname-function

_{Do not modify the class generated by Qt Designer but you must import it into your main script, in this case you must generate the .py again using pyuic5 your_design.ui -o gui.py -x.}

You should not use waitKey() if the window that shows the opencv frame is not created by opencv since it will not handle keyboard events, that is, if the window is generated by X technology and opencv only serves to obtain the image from some device then X technology must handle keyboard events. And in this case that technology is Qt.

This is pointed out in the docs:

Note: The function only works if there is at least one HighGUI window created and the window is active. If there are several HighGUI windows, any of them can be active.

On the other hand, the task of reading a frame does not consume much time, so you should not use a while True since it blocks the eventloop of the GUI but a timer is enough (in the case of Qt you must use a QTimer).

Considering the above, the solution is: