Overview and philosophy
bismon (this is a temporary name) is a persistent monitor which (in the future) would interact with the GCC compiler thru plugins.
It is (or will become) somehow a successor to my old GCC MELT project; the medium-term goal is also static program source code analysis with the help of GCC.
My (Basile Starynkevitch, employed
at CEA, LIST in France) work on
partly funded (from start of 2018 to end of 2020) by the European
Union, Horizon H2020 programme, CHARIOT
project, under Grant Agreement No 780075. Within CHARIOT I will focus
on analysis of some kind of
IoT software coded
in C or C++ and (cross-) compiled by GCC on
some Linux desktop.
bismon still in pre alpha-stage, and it is free software under GPLv3+ license. It is intended for a Linux x86-64 desktop developer's workstation (won't work on Windows or MacOSX or Android).
Develop some kind of high-level (more expressive, more declarative) domain-specific language to facilitate static program source code analysis above GCC and generate GCC plugins for it, so same motivations as GCC MELT (and more broadly related -in motivations- to Coccinnelle, Frama-C, Rascal, CrossMiner, Clang analyser, Clasp etc...).
Important features and goals of that domain-specific language and its implementation include:
orthogonal persistence; this is a major feature (useful for whole program static source code analysis of an analyzed program made of several translation units, each compiled independently) which was not realistically addable to GCC MELT so requires a complete redesign. The
bismonprocess is expected to be relatively long-lived -server like- and retains most of its data from one run to the next (in
store*.bmontextual files). In the future the
bismonprocess will communicate with
g++(cross-)compilation processes (using some GCC plugin, to be generated by
multi-threaded but without any GIL. A small thread pool of worker threads is repeatedly and concurrently fetching tasklets from a global agenda. Each tasklet runs quickly (milliseconds) in some worker thread and can update that agenda (e.g. by adding itself to be continued).
precisely garbage collected
declarative, with good pattern matching and rules formalisms
generating GCC plugins (in C++) which would interact with
bismonby some RPC mechanism
Notice that the syntax and semantics (still undocumented) of
bismon is work-in-progress and subject to change incompatibly.
bismon will be completed to point of being usable, it would be
typically used (thru some web interface) by a small team of developers
working together on some (common) software project coded mostly in C
or C++ (and preferably a free software project).
On Linux/x86-64 (e.g. Debian/Unstable or recent Ubuntu) only (won't work on 32 bits machines!):
- recent GCC (so GCC 7
or preferably GCC 8 ...), with C and C++ and JIT
support and plugins enabled (check with
gcc -v; if your system
g++lack support for plugins and libgccjit, you should build and install a recent GCC release from its source code, and configure it to provide them.). An old GCC (e.g. version 6 or earlier) cannot be used.
bismon is in C99 or C11 (including an increasing amount of
generated code), but some few code is in C++14.
ninja builder, version 1.8 or newer is need (and is started by
make). Don't use an older one (check with
ninja --version; if that does not work, your
ninjais too old).
libonion is needed for the web interface (at least 0.8.99 -master- later than june 10th 2018, or 0.9)
GNU make 4 or better
ccache is used to avoid useless recompilations.
libbacktrace - it is sometimes part of your system GCC, but you'll better install it separately (e.g. in your
markdown is required for some documentation, such as this
tarfile postprocessor) is used to generate documentation.
relevant Debian/Ubuntu build-dependency packages
On Debian/Unstable or Ubuntu,
apt-get install build-essential make ninja gcc-8 g++-8 gcc-8-plugin-dev libgccjit-8-dev ccache
for the building infrastructure.
We still need
apt-get install libgtk-3-dev for GTK 3. This may pull a lot of dependencies.
libbacktrace is not independently packaged in Debian. I recommend building and installing
it from its source code, or else (not recommended,
Makefile to uses your system GCC compiler's one.
libonion is not independently packaged in Debian.
apt-get install markdown indent astyle tardy and
apt-get install texlive texlive-full hevea
dependencies/ subdirectory is for
git submodule-s related to
locale to be sure that your localization is POSIX compliant or
English (British or American) in UTF-8 (it cannot for instance be
Italian or Greek or French). So it should be
en_GB.UTF-8. You might want to set your environment
variables appropriately (at least
LC_ALL=en_US.UTF-8, with no other
environment variable). See
git repository as usual, and build then use
inside the obtained source tree.
Look into the
Makefile, and edit it if needed; perhaps update the
LIBES= lines, e.g. to use your system's GCC
libbacktrace, by adding
$(shell gcc-7 -print-file-name=include)
PREPROFLAGS= line, and
$(shell gcc-7 -print-file-name=libbacktrace.a) to the
LIBES= line. Of course
replace the 7 by 8 if appropriate. Maybe you need to explicitly set
GXX= to your specific GCC C and C++ compilers.
The persistency mechanism is tested by
./bismon program is (temporarily) still using GTK and
libonion. We want to get rid of GTK. It is symlinked as
Be sure to run
--help at first to
understand the program options that are available.
adding yourself as a contributor
bismon (at least its Web version) needs to know about you. So you
should register yourself once to it (and that would grow its
persistent state). And
bismon (more exactly
bismonion) has a login
form, so you should have a password (specific to
to any other password you have).
You first need to initialize an empty password file (the default
password file is
~/passwords_BM; you could specify another one on
the command line). So run the command
touch ~/passwords_BM in a
terminal (shell) to create that empty file. Then you need to restrict
its permission (readable and writable by your Unix user only) with
chmod u+rw,go-rwx ~/passwords_BM. At last, check with
ls -ls ~/passwords_BM that this file is empty and readable & writable only
Then you'll register yourself. If
Alan Turing is your name or
email@example.com is your main email, with your secondary
turing@localhost, you can add yourself to
running it (actually
./bismonion) with something similar to
--contributor='Alan Turing;firstname.lastname@example.org;turing@localhost' and
--dump-after-load=. program options. Of course you
by whatever is appropriate for you. The secondary email (also called
alias) is optional. If you don't use it (so if you don't provide any
alias, which is likely - so replace
turing@localhost with an empty
bismon knows no more about you than
git does (see git
user.name). You might even code some shell script to extract that
personal data information from
git and put it into
At last you need to set your password (it is unrelated to other
passwords in your computer or on the web, but should has at least 10
Unicode characters, and digits, letters, punctuations), as known to
bismonion, using the
--add-passwords option (also with
--dump-after-load=.). To set your initial password to
mypass!123456 create some temporary text file (it contains
contributor names and their updated passwords in clear text, so you
should not keep it), perhaps
/tmp/addpassbismon, containing for
Alan Turing:mypass!123456 add run
--add-passwords=/tmp/addpassbismon --batch then remove
/tmp/addpassbismon. Of course you'll better write some shell script
wrapping that, and be sure to have a strong enough password which is
not in this
You might perhaps add a few other users (probably less than a dozen)
that you trust and that can work with you. Every user could mess or
bismon system as easily as you could. Be then sure to be
compliant with the GDPR if any of your
users is European (and GDPR compliance is then your
responsability). The login form is templated (with code from
web_ONIONBM.c) from source file
login_ONIONBM.thtml (and you might
improve the text inside that file if you want).
It is not really usable yet except by me (Basile) in july 2018 (no
static source code analysis yet, no generation of GCC plugins yet). If
you want to see something using GTK, run
./bismongtk then type
the_system in the command window labelled new-bismon, then both
Ctrl and Return keys pressed together. If you want to see
something thru the web interface, run
./bismonion then open its URL
localhost:8086/ or whatever has been specified with
--web-base) in your web browser.
It is recommended to run
make clean once in a while (e.g. daily or
weekly). When generating files,
bismon makes a backup of their
This is unreleased free software
The license (GPLv3+) is likely to not change (it is contractually specified in the CHARIOT grant). The copyright notice is probably wrong: in generated files, it is not yet conforming to GPL expectations. Once formally released (in 2020), it is likely that the copyright owner will change (probably to CEA, my employer). These details are pending bugs, but there are much more other bugs too.