multiversion | Easy function multiversioning for Rust

As answered in the comments:

I'd recommend moving each of the CPU targets to a separate translation unit, which is compiled with the corresponding compiler flags. The common doStuffImpl function can be implemented in a header, included in each of the TUs. In that header, you can use predefined macros like __AVX__ to test for available ISA extensions. The __attribute__((target)) attributes are no longer needed and can be removed in this case.

Figured out the solution. It's due to swagger.config instance problem. Solved by adding the assembly [assembly: PreApplicationStartMethod(typeof(SwaggerConfig), "Register")] in swagger.config and moved all the versioning code to webapi.config. Not sure why this has to be done for minor versions to work but it worked for me.

I don't understand why -release won't work for you, so I'll just leave that solution out of this answer. The procedure is similar, but will create different .so file names (e.g. libfoo-1.2.so and libfoo.so) but the same .a name.

configure.ac

Call is an SQL keyword not a PLSQL keyword. It will work outside the anonymous block, but not inside it. PLSQL will take care of this for you so all you should need is...

For determining serializability between two transactions only the dependencies between their reads and writes are needed, not their commits, nor their aborts (obviously for the aborts).

So, in the example, if T1 started before T2, and T2 has been committed, but not T1 yet, then their schedule is serializable, i.e., T1 can be committed, if it is equivalent to any one of "T1 then T2" or "T2 then T1". It does not matter which committed first.

So the Wikipedia page is correct: the actual schedule must be equivalent to the serial schedule "T1 then T2" because T1 read the value before T2 wrote it.

pg_dump doesn't create any row versions (a.k.a tuples).

The only impact of pg_dump are the increased I/O load and the long running transaction it creates. The long transaction will keep autovacuum from reclaimimg dead tuples for the duration of the dump.

Normally that is no big problem unless you have very high write activity in the database. To mitigate that problem, you could create a streaming replication standby server, set max_standby_streaming_delay to more than the duration of pg_dump and let pg_dump run there.

This is the essence of your question:

how do I guarantee that, for ...... any number of SELECT statements ..... inside one transaction ....... I will get data as it existed at the time I started the transaction?

This is exactly what Repeatable Read Isolation Level guarantees:

The Repeatable Read isolation level only sees data committed before the transaction began; it never sees either uncommitted data or changes committed during transaction execution by concurrent transactions. (However, the query does see the effects of previous updates executed within its own transaction, even though they are not yet committed.) This is a stronger guarantee than is required by the SQL standard for this isolation level, and prevents all of the phenomena described in Table 13-1. As mentioned above, this is specifically allowed by the standard, which only describes the minimum protections each isolation level must provide.

This level is different from Read Committed in that a query in a repeatable read transaction sees a snapshot as of the start of the transaction, not as of the start of the current query within the transaction. Thus, successive SELECT commands within a single transaction see the same data, i.e., they do not see changes made by other transactions that committed after their own transaction started.

A practical example - let say we have 2 simple tables: