blacktoppstudios / mezz_staticfoundation Goto Github PK

This needs to be able be able to concatenate strings, checking length, indexing and things required to implement these.

Comparing for equality and streaming would be nice, but are stretch goals

Apparently it is super outdated

In GCC attribute__((const)) and attribute((pure)) are used to mark functions as depending only their input. Having this information allows compilers to make more aggressive optimizations correctly and more easily.

According to the GCC manual - https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Function-Attributes.html :

pure
Many functions have no effects except the return value and their return value depends only on the parameters and/or global variables. Such a function can be subject to common subexpression elimination and loop optimization just as an arithmetic operator would be. These functions should be declared with the attribute pure. For example,

          int square (int) __attribute__ ((pure));

says that the hypothetical function square is safe to call fewer times than the program says.

Some of common examples of pure functions are strlen or memcmp. Interesting non-pure functions are functions with infinite loops or those depending on volatile memory or other system resource, that may change between two consecutive calls (such as feof in a multithreading environment).

The attribute pure is not implemented in GCC versions earlier than 2.96.

Const is just like pure except the function also isn't allowed to dereference pointers it is passed. Here is the manual entry for the const attribute:

const
Many functions do not examine any values except their arguments, and have no effects except the return value. Basically this is just slightly more strict class than the pure attribute below, since function is not allowed to read global memory.

Note that a function that has pointer arguments and examines the data pointed to must not be declared const. Likewise, a function that calls a non-const function usually must not be const. It does not make sense for a const function to return void.

The attribute const is not implemented in GCC versions earlier than 2.5. An alternative way to declare that a function has no side effects, which works in the current version and in some older versions, is as follows:

          typedef int intfn ();

          extern const intfn square;

This approach does not work in GNU C++ from 2.6.0 on, since the language specifies that the `const' must be attached to the return value.

Most other compilers seem to support GCC attributes including Clang and intel: https://stackoverflow.com/questions/2798188/pure-const-function-attributes-in-different-compilers

I propose that we add two macros for tagging functions PURE for const and PURE_WITH_GLOBAL for pure. Which apply these attributes to functions in compilers that support them and resolve to empty on compilers that don't. We might want to come up with better names before.

This includes migrating most of the mezzException stuff from the old Mezzanine repo.

The new version of the Jagati has a bunch of features to simplify CMakeLists.txt creation. It should be used instead of the old Pre-12 code which requires deeper involvement with the Jagati.

TParams are confusing to people with even moderate knowledge. We need to make an effort to make the docs on these less copypasta and more understandable to those at even new skill level. First target should be the static string.

When this is resolved in this repo, Mezz_Test and Mezz_Foundation should be reviewed as well.

Add "no-var-tracking-assignments" (GCC/MinGW) or "no-var-tracking" (Clang/AppleClang) to all applicable builds in CI.

With #3 done this is needed to prove its done.

Currently Primitive CPU detection is in place, this needs to be tested and needs to have all the runtime support as the other platform detection features.

This is a bug because it leaves performance on the table and this is an enhancement because it does work now. It should be straightforward because this is a tiny library, but each function that reaches in the std library needs to check the docs that it will never throw.

If someone wants to attempt this who has never used C++11 noexept here is the cppreference docs: http://en.cppreference.com/w/cpp/language/noexcept_spec

A solution to thing will include testing on Appveyor, a fix in jagati.cmake and a release with this fixed.

Right now emscripten is not as well supported as the other compilers it needs the style of macros to all conditional compilation. These also need to be integrated into the unit tests.

This only works on gcc compatible compilers and is silently ignored for msvc. This needs to either fail or work as expected on those compilers.

The newest version of the Jagati, still in PR, has many opinionated features that can simplify certain aspects of CMake creation, likely the config file stuff will stay complex, but this ought to get at least a little shorter.

This will likely include some major Jagati work. The stuff that makes the doxygen generation work should be put in its own repo to make it less depedent on the mezzanine and easier to work, even when using the Mezzanine.

That sounded contradictory... Right now all the logic for the documentation stuff is stored in the Mezz_StaticFoundation CMake. If it were in the Jagati all the important data could be manipulated by Jagati functions and Macros.

Whatever we do in the Foundation for a timeout we should do to this one: BlackToppStudios/Mezz_Foundation#31

When generating doxygen docs the docs work but are poorly formatted. The header produced show the list of bread crumbs in a single vertical line instead of several horizontal rows, see attached screenshot:

Here are the steps required to duplicate, starting from the directory with this repo checked out. These were done on an ubuntu 17.10 machine with firefox 57, chromium 63, cmake 3.9.1 and doxygen 1.8.13:

$ cd ../
$ mkdir Mezz_StaticFoundation-build
$ cd Mezz_StaticFoundation-build/
$ cmake ../Mezz_StaticFoundation -GNinja
$ ninja
$ ./StaticFoundation_Tester  # Not required but it is worth noting that all tests passed
$ chromium-browser Doxygen/html/index.html 
$ firefox Doxygen/html/index.html 

Codacy does automatic style and linter checks: https://www.codacy.com/

IsItMaintained helps to know if we are ignoring people or if our projects are appropriately active: http://isitmaintained.com/

Coveralls is another tool to help with test coverage: https://coveralls.io/

CII best practices helps with making sure we are keeping project transparency and community visibility: https://bestpractices.coreinfrastructure.org/en

Wandbox has tools to try it online: https://wandbox.org/

If we just want to rack up badges we can also link to our issues, our license too.

This really shouldn't near more information...

Don't forget the Cmake files.

Get Jenkins working again and see what new features can easily be added and what benefits can be had if any for the project and team.

We should try to add a valgrind test to as many of the CI test builds and possible.

Spectre is new class of security vulnerability that can cause data to be read from Cache when it shouldn't be able to be read. Most compilers are automatically correcting code vulnerable to this. These corrections do slow down the code with the fixes.

Video games are generally not privacy sensitive, but some may deal with credit card numbers, passwords and potentially other unforeseen sensitive information. It seems that using these mitigations by default is a good idea. Video games also tend to have performance sensitive loops or other things that might require Spectre mitigation on the hot path.

Some compilers produce warnings when inserting these mitigations. Currently the game developer can suppress Spectre warnings in non-performance critical code with something like the following:

SAVE_WARNING_STATE
SUPPRESS_VC_WARNING(5045)
// Code that needs spectre fixes
RESTORE_WARNING_STATE

The game developer also needs a macro that actually suppresses Spectre mitigations. On platforms and compilers this macro should be empty so the code the game developer's code does need to change and automatically inserts spectre mitigation where required.

https://blogs.msdn.microsoft.com/vcblog/2018/01/15/spectre-mitigations-in-msvc/

Post C++11 we should be using std::chrono for most our timing needs, with very few exceptions. We could keep this type around by renaming it "OldTimeMarker" or "LegacyTimeMarker". But regardless a default time marking type in the Mezzanine should be something from std::chrono.

This would be pretty straightforward, it will just be tedious.