CryptoURANUS Economics

Anti-AdBlocker

Friday, July 26, 2019

Monero-(XMR) 30-G/hs FPGA


Monero




Copyright © 2014-2019 The Monero Project.
Portions Copyright © 2012-2013 The Cryptonote developers.



BTC















Table of Contents

Development resources

Vulnerability response

Research

The Monero Research Lab is an open forum where the community coordinates research into Monero cryptography, protocols, fungibility, analysis, and more. We welcome collaboration and contributions from outside researchers! Because not all Lab work and publications are distributed as traditional preprints or articles, they may be easy to miss if you are conducting literature reviews for your own Monero research. You are encouraged to get in touch with our researchers if you have questions, wish to collaborate, or would like guidance to help avoid unnecessarily duplicating earlier or known work.
Our researchers are available on IRC in #monero-research-lab on Freenode or by email:

Announcements

  • You can subscribe to an announcement listserv to get critical announcements from the Monero core team. The announcement list can be very helpful for knowing when software updates are needed.

Translations

The CLI wallet is available in different languages. If you want to help translate it, see our self-hosted localization platform, Pootle, on translate.getmonero.org. Every translation must be uploaded on the platform, pull requests directly editing the code in this repository will be closed. If you need help with Pootle, you can find a guide with screenshots here.
If you need help/support/info about translations, contact the localization workgroup. You can find the complete list of contacts on the repository of the workgroup: monero-translations.

Build

IMPORTANT

These builds are of the master branch, which is used for active development and can be either unstable or incompatible with release software. Please compile release branches.
Operating System Processor Status
Ubuntu 16.04 i686 Ubuntu 16.04 i686
Ubuntu 16.04 amd64 Ubuntu 16.04 amd64
Ubuntu 16.04 armv7 Ubuntu 16.04 armv7
Debian Stable armv8 Debian armv8
macOS 10.11 amd64 macOS 10.11 amd64
macOS 10.12 amd64 macOS 10.12 amd64
macOS 10.13 amd64 macOS 10.13 amd64
FreeBSD 11 amd64 FreeBSD 11 amd64
DragonFly BSD 4.6 amd64 DragonFly BSD amd64
Windows (MSYS2/MinGW) i686 Windows (MSYS2/MinGW) i686
Windows (MSYS2/MinGW) amd64 Windows (MSYS2/MinGW) amd64

Coverage

Type Status
Coverity Coverity Status
Coveralls Coveralls Status
License License

Introduction

Monero is a private, secure, untraceable, decentralised digital currency. You are your bank, you control your funds, and nobody can trace your transfers unless you allow them to do so.
Privacy: Monero uses a cryptographically sound system to allow you to send and receive funds without your transactions being easily revealed on the blockchain (the ledger of transactions that everyone has). This ensures that your purchases, receipts, and all transfers remain absolutely private by default.
Security: Using the power of a distributed peer-to-peer consensus network, every transaction on the network is cryptographically secured. Individual wallets have a 25 word mnemonic seed that is only displayed once, and can be written down to backup the wallet. Wallet files are encrypted with a passphrase to ensure they are useless if stolen.
Untraceability: By taking advantage of ring signatures, a special property of a certain type of cryptography, Monero is able to ensure that transactions are not only untraceable, but have an optional measure of ambiguity that ensures that transactions cannot easily be tied back to an individual user or computer.
Decentralization: The utility of monero depends on its decentralised peer-to-peer consensus network - anyone should be able to run the monero software, validate the integrity of the blockchain, and participate in all aspects of the monero network using consumer-grade commodity hardware. Decentralization of the monero network is maintained by software development that minimizes the costs of running the monero software and inhibits the proliferation of specialized, non-commodity hardware.

About this project

This is the core implementation of Monero. It is open source and completely free to use without restrictions, except for those specified in the license agreement below. There are no restrictions on anyone creating an alternative implementation of Monero that uses the protocol and network in a compatible manner.
As with many development projects, the repository on Github is considered to be the “staging” area for the latest changes. Before changes are merged into that branch on the main repository, they are tested by individual developers in their own branches, submitted as a pull request, and then subsequently tested by contributors who focus on testing and code reviews. That having been said, the repository should be carefully considered before using it in a production environment, unless there is a patch in the repository for a particular show-stopping issue you are experiencing. It is generally a better idea to use a tagged release for stability.
Anyone is welcome to contribute to Monero’s codebase! If you have a fix or code change, feel free to submit it as a pull request directly to the “master” branch. In cases where the change is relatively small or does not affect other parts of the codebase it may be merged in immediately by any one of the collaborators. On the other hand, if the change is particularly large or complex, it is expected that it will be discussed at length either well in advance of the pull request being submitted, or even directly on the pull request.

Supporting the project

Monero is a 100% community-sponsored endeavor. If you want to join our efforts, the easiest thing you can do is support the project financially. Both Monero and Bitcoin donations can be made to donate.getmonero.org if using a client that supports the OpenAlias standard. Alternatively you can send XMR to the Monero donation address via the donate command (type help in the command-line wallet for details).
The Monero donation address is: 44AFFq5kSiGBoZ4NMDwYtN18obc8AemS33DBLWs3H7otXft3XjrpDtQGv7SqSsaBYBb98uNbr2VBBEt7f2wfn3RVGQBEP3A (viewkey: f359631075708155cc3d92a32b75a7d02a5dcf27756707b47a2b31b21c389501)
The Bitcoin donation address is: 1KTexdemPdxSBcG55heUuTjDRYqbC5ZL8H
Core development funding and/or some supporting services are also graciously provided by sponsors:

There are also several mining pools that kindly donate a portion of their fees, a list of them can be found on our Bitcointalk post.

License

See LICENSE.

Contributing

If you want to help out, see CONTRIBUTING for a set of guidelines.

Scheduled software upgrades

Monero uses a fixed-schedule software upgrade (hard fork) mechanism to implement new features. This means that users of Monero (end users and service providers) should run current versions and upgrade their software on a regular schedule. Software upgrades occur during the months of April and October. The required software for these upgrades will be available prior to the scheduled date. Please check the repository prior to this date for the proper Monero software version. Below is the historical schedule and the projected schedule for the next upgrade. Dates are provided in the format YYYY-MM-DD.
| Software upgrade block height | Date | Fork version | Minimum Monero version | Recommended Monero version | Details |
| ------------------------------ | -----------| ----------------- | ---------------------- | -------------------------- | ---------------------------------------------------------------------------------- | | 1009827 | 2016-03-22 | v2 | v0.9.4 | v0.9.4 | Allow only >= ringsize 3, blocktime = 120 seconds, fee-free blocksize 60 kb | | 1141317 | 2016-09-21 | v3 | v0.9.4 | v0.10.0 | Splits coinbase into denominations | | 1220516 | 2017-01-05 | v4 | v0.10.1 | v0.10.2.1 | Allow normal and RingCT transactions | | 1288616 | 2017-04-15 | v5 | v0.10.3.0 | v0.10.3.1 | Adjusted minimum blocksize and fee algorithm | | 1400000 | 2017-09-16 | v6 | v0.11.0.0 | v0.11.0.0 | Allow only RingCT transactions, allow only >= ringsize 5 | | 1546000 | 2018-04-06 | v7 | v0.12.0.0 | v0.12.3.0 | Cryptonight variant 1, ringsize >= 7, sorted inputs | 1685555 | 2018-10-18 | v8 | v0.13.0.0 | v0.13.0.4 | max transaction size at half the penalty free block size, bulletproofs enabled, cryptonight variant 2, fixed ringsize 11 | 1686275 | 2018-10-19 | v9 | v0.13.0.0 | v0.13.0.4 | bulletproofs required | 1788000 | 2019-03-09 | v10 | v0.14.0.0 | v0.14.1.0 | New PoW based on Cryptonight-R, new block weight algorithm, slightly more efficient RingCT format | 1788720 | 2019-03-10 | v11 | v0.14.0.0 | v0.14.1.0 | forbid old RingCT transaction format | XXXXXXX | 2019-10-XX | XX | XXXXXXXXX | XXXXXXXXX | X
X’s indicate that these details have not been determined as of commit date.

Release staging schedule and protocol

Approximately three months prior to a scheduled software upgrade, a branch from Master will be created with the new release version tag. Pull requests that address bugs should then be made to both Master and the new release branch. Pull requests that require extensive review and testing (generally, optimizations and new features) should not be made to the release branch.

Compiling Monero from source

Dependencies

The following table summarizes the tools and libraries required to build. A few of the libraries are also included in this repository (marked as “Vendored”). By default, the build uses the library installed on the system, and ignores the vendored sources. However, if no library is found installed on the system, then the vendored source will be built and used. The vendored sources are also used for statically-linked builds because distribution packages often include only shared library binaries (.so) but not static library archives (.a).
Dep Min. version Vendored Debian/Ubuntu pkg Arch pkg Fedora Optional Purpose
GCC 4.7.3 NO build-essential base-devel gcc NO
CMake 3.5 NO cmake cmake cmake NO
pkg-config any NO pkg-config base-devel pkgconf NO
Boost 1.58 NO libboost-all-dev boost boost-devel NO C++ libraries
OpenSSL basically any NO libssl-dev openssl openssl-devel NO sha256 sum
libzmq 3.0.0 NO libzmq3-dev zeromq cppzmq-devel NO ZeroMQ library
OpenPGM ? NO libpgm-dev libpgm openpgm-devel NO For ZeroMQ
libnorm[2] ? NO libnorm-dev
` YES For ZeroMQ
libunbound 1.4.16 YES libunbound-dev unbound unbound-devel NO DNS resolver
libsodium ? NO libsodium-dev libsodium libsodium-devel NO cryptography
libunwind any NO libunwind8-dev libunwind libunwind-devel YES Stack traces
liblzma any NO liblzma-dev xz xz-devel YES For libunwind
libreadline 6.3.0 NO libreadline6-dev readline readline-devel YES Input editing
ldns 1.6.17 NO libldns-dev ldns ldns-devel YES SSL toolkit
expat 1.1 NO libexpat1-dev expat expat-devel YES XML parsing
GTest 1.5 YES libgtest-dev[1] gtest gtest-devel YES Test suite
Doxygen any NO doxygen doxygen doxygen YES Documentation
Graphviz any NO graphviz graphviz graphviz YES Documentation
[1] On Debian/Ubuntu libgtest-dev only includes sources and headers. You must build the library binary manually. This can be done with the following command sudo apt-get install libgtest-dev && cd /usr/src/gtest && sudo cmake . && sudo make && sudo mv libg* /usr/lib/ [2] libnorm-dev is needed if your zmq library was built with libnorm, and not needed otherwise
Install all dependencies at once on Debian/Ubuntu:

Install all dependencies at once on macOS with the provided Brewfile:
``` brew update && brew bundle --file=contrib/brew/Brewfile ```

FreeBSD one liner for required to build dependencies
```pkg install git gmake cmake pkgconf boost-libs cppzmq libsodium```

### Cloning the repository

Clone recursively to pull-in needed submodule(s):

`$ git clone --recursive https://github.com/monero-project/monero`

If you already have a repo cloned, initialize and update:

`$ cd monero && git submodule init && git submodule update`

### Build instructions

Monero uses the CMake build system and a top-level [Makefile](Makefile) that
invokes cmake commands as needed.

#### On Linux and macOS

* Install the dependencies
* Change to the root of the source code directory, change to the most 
recent release branch, and build:

    ```bash
    cd monero
    git checkout release-v0.14
    make
    ```

    *Optional*: If your machine has several cores and enough memory, enable
    parallel build by running `make -j<number of threads>` instead of `make`. For
    this to be worthwhile, the machine should have one core and about 2GB of RAM
    available per thread.

    *Note*: If cmake can not find zmq.hpp file on macOS, installing `zmq.hpp` from
    https://github.com/zeromq/cppzmq to `/usr/local/include` should fix that error.

    *Note*: The instructions above will compile the most stable release of the
    Monero software. If you would like to use and test the most recent software,
    use ```git checkout master```. The master branch may contain updates that are
    both unstable and incompatible with release software, though testing is always
    encouraged.
 * The resulting executables can be found in `build/release/bin`

* Add `PATH="$PATH:$HOME/monero/build/release/bin"` to `.profile`

* Run Monero with `monerod --detach`

* **Optional**: build and run the test suite to verify the binaries:

    ```bash
    make release-test
    ```

    *NOTE*: `core_tests` test may take a few hours to complete.

* **Optional**: to build binaries suitable for debugging:

    ```bash
    make debug
    ```

* **Optional**: to build statically-linked binaries:

    ```bash
    make release-static
    ```

Dependencies need to be built with -fPIC. Static libraries usually aren't, 
so you may have to build them yourself with -fPIC. Refer to their documentation for how to build them.

* **Optional**: build documentation in `doc/html` (omit `HAVE_DOT=YES` if `graphviz` is not installed):

    ```bash
    HAVE_DOT=YES doxygen Doxyfile
    ```

#### On the Raspberry Pi

Tested on a Raspberry Pi Zero with a clean install of minimal Raspbian Stretch (2017-09-07 or later) from https://www.raspberrypi.org/downloads/raspbian/. If you are using Raspian Jessie, [please see note in the following section](#note-for-raspbian-jessie-users).

* `apt-get update && apt-get upgrade` to install all of the latest software

* Install the dependencies for Monero from the 'Debian' column in the table above.

* Increase the system swap size:

    ```bash
    sudo /etc/init.d/dphys-swapfile stop  
    sudo nano /etc/dphys-swapfile  
    CONF_SWAPSIZE=2048
    sudo /etc/init.d/dphys-swapfile start
    ```

* If using an external hard disk without an external power supply, ensure it gets enough power to avoid hardware issues when syncing, by adding the line "max_usb_current=1" to /boot/config.txt

* Clone monero and checkout the most recent release version:

    ```bash
    git clone https://github.com/monero-project/monero.git
    cd monero
    git checkout tags/v0.14.1.0
    ```

* Build:

    ```bash
    make release
    ```

* Wait 4-6 hours

* The resulting executables can be found in `build/release/bin`

* Add `PATH="$PATH:$HOME/monero/build/release/bin"` to `.profile`

* Run Monero with `monerod --detach`

* You may wish to reduce the size of the swap file after the build has finished, and delete the boost directory from your home directory

#### *Note for Raspbian Jessie users:*

If you are using the older Raspbian Jessie image, compiling Monero is a bit more complicated. The version of Boost available in the Debian Jessie repositories is too old to use with Monero, and thus you must compile a newer version yourself. The following explains the extra steps, and has been tested on a Raspberry Pi 2 with a clean install of minimal Raspbian Jessie.

* As before, `apt-get update && apt-get upgrade` to install all of the latest software, and increase the system swap size

    ```bash
    sudo /etc/init.d/dphys-swapfile stop
    sudo nano /etc/dphys-swapfile
    CONF_SWAPSIZE=2048
    sudo /etc/init.d/dphys-swapfile start
    ```


* Then, install the dependencies for Monero except `libunwind` and `libboost-all-dev`

* Install the latest version of boost (this may first require invoking `apt-get remove --purge libboost*` to remove a previous version if you're not using a clean install):

    ```bash
    cd
    wget https://sourceforge.net/projects/boost/files/boost/1.64.0/boost_1_64_0.tar.bz2
    tar xvfo boost_1_64_0.tar.bz2
    cd boost_1_64_0
    ./bootstrap.sh
    sudo ./b2
    ```

* Wait ~8 hours

    ```bash    
    sudo ./bjam cxxflags=-fPIC cflags=-fPIC -a install
    ```

* Wait ~4 hours

* From here, follow the [general Raspberry Pi instructions](#on-the-raspberry-pi) from the "Clone monero and checkout most recent release version" step.

#### On Windows:

Binaries for Windows are built on Windows using the MinGW toolchain within
[MSYS2 environment](https://www.msys2.org). The MSYS2 environment emulates a
POSIX system. The toolchain runs within the environment and *cross-compiles*
binaries that can run outside of the environment as a regular Windows
application.

**Preparing the build environment**

* Download and install the [MSYS2 installer](https://www.msys2.org), either the 64-bit or the 32-bit package, depending on your system.
* Open the MSYS shell via the `MSYS2 Shell` shortcut
* Update packages using pacman:  

    ```bash
    pacman -Syu
    ```

* Exit the MSYS shell using Alt+F4  
* Edit the properties for the `MSYS2 Shell` shortcut changing "msys2_shell.bat" to "msys2_shell.cmd -mingw64" for 64-bit builds or "msys2_shell.cmd -mingw32" for 32-bit builds
* Restart MSYS shell via modified shortcut and update packages again using pacman:  

    ```bash
    pacman -Syu
    ```


* Install dependencies:

    To build for 64-bit Windows:

    ```bash
    pacman -S mingw-w64-x86_64-toolchain make mingw-w64-x86_64-cmake mingw-w64-x86_64-boost mingw-w64-x86_64-openssl mingw-w64-x86_64-zeromq mingw-w64-x86_64-libsodium mingw-w64-x86_64-hidapi
    ```

    To build for 32-bit Windows:

    ```bash
    pacman -S mingw-w64-i686-toolchain make mingw-w64-i686-cmake mingw-w64-i686-boost mingw-w64-i686-openssl mingw-w64-i686-zeromq mingw-w64-i686-libsodium mingw-w64-i686-hidapi
    ```

* Open the MingW shell via `MinGW-w64-Win64 Shell` shortcut on 64-bit Windows
  or `MinGW-w64-Win64 Shell` shortcut on 32-bit Windows. Note that if you are
  running 64-bit Windows, you will have both 64-bit and 32-bit MinGW shells.

**Cloning**

* To git clone, run:

    ```bash
    git clone --recursive https://github.com/monero-project/monero.git
    ```

**Building**

* Change to the cloned directory, run:

    ```bash
    cd monero
    ```

* If you would like a specific [version/tag](https://github.com/monero-project/monero/tags), do a git checkout for that version. eg. 'v0.14.1.0'. If you don't care about the version and just want binaries from master, skip this step:
 
    ```bash
    git checkout v0.14.1.0
    ```

* If you are on a 64-bit system, run:

    ```bash
    make release-static-win64
    ```

* If you are on a 32-bit system, run:

    ```bash
    make release-static-win32
    ```

* The resulting executables can be found in `build/release/bin`

* **Optional**: to build Windows binaries suitable for debugging on a 64-bit system, run:

    ```bash
    make debug-static-win64
    ```

* **Optional**: to build Windows binaries suitable for debugging on a 32-bit system, run:

    ```bash
    make debug-static-win32
    ```

* The resulting executables can be found in `build/debug/bin`

### On FreeBSD:

The project can be built from scratch by following instructions for Linux above(but use `gmake` instead of `make`). If you are running monero in a jail you need to add the flag: `allow.sysvipc=1` to your jail configuration, otherwise lmdb will throw the error message: `Failed to open lmdb environment: Function not implemented`.

We expect to add Monero into the ports tree in the near future, which will aid in managing installations using ports or packages.

### On OpenBSD:

#### OpenBSD < 6.2

This has been tested on OpenBSD 5.8.

You will need to add a few packages to your system. `pkg_add db cmake gcc gcc-libs g++ gtest`.

The doxygen and graphviz packages are optional and require the xbase set.

The Boost package has a bug that will prevent librpc.a from building correctly. 
In order to fix this, you will have to Build boost yourself from scratch. Follow 
the directions here (under "Building Boost"):
https://github.com/bitcoin/bitcoin/blob/master/doc/build-openbsd.md

You will have to add the serialization, date_time, and regex modules to Boost 
when building as they are needed by Monero.

To build: `env CC=egcc CXX=eg++ CPP=ecpp 
DEVELOPER_LOCAL_TOOLS=1 BOOST_ROOT=/path/to/the/boost/you/built make release-static-64`

#### OpenBSD 6.2 and 6.3

You will need to add a few packages to your system. `pkg_add cmake zeromq libiconv`.

The doxygen and graphviz packages are optional and require the xbase set.


Build the Boost library using clang. This guide is derived from: 
https://github.com/bitcoin/bitcoin/blob/master/doc/build-openbsd.md

We assume you are compiling with a non-root user and you have `doas` enabled.

Note: do not use the boost package provided by OpenBSD, as we are installing boost to
 `/usr/local`.

```bash
# Create boost building directory
mkdir ~/boost
cd ~/boost

# Fetch boost source
ftp -o boost_1_64_0.tar.bz2 
https://netcologne.dl.sourceforge.net/project/boost/boost/1.64.0/boost_1_64_0.tar.bz2

# MUST output: (SHA256) boost_1_64_0.tar.bz2: OK
echo "7bcc5caace97baa948931d712ea5f37038dbb1c5d89b43ad4def4ed7cb683332 boost_1_64_0.tar.bz2" | sha256 -c
tar xfj boost_1_64_0.tar.bz2

# Fetch and apply boost patches, required for OpenBSD
ftp -o boost_test_impl_execution_monitor_ipp.patch https://raw.githubusercontent.com/openbsd/ports/bee9e6df517077a7269ff0dfd57995f5c6a10379/devel/boost/patches/patch-boost_test_impl_execution_monitor_ipp
ftp -o boost_config_platform_bsd_hpp.patch https://raw.githubusercontent.com/openbsd/ports/90658284fb786f5a60dd9d6e8d14500c167bdaa0/devel/boost/patches/patch-boost_config_platform_bsd_hpp

# MUST output: (SHA256) boost_config_platform_bsd_hpp.patch: OK
echo "1f5e59d1154f16ee1e0cc169395f30d5e7d22a5bd9f86358f738b0ccaea5e51d boost_config_platform_bsd_hpp.patch" | sha256 -c
# MUST output: (SHA256) boost_test_impl_execution_monitor_ipp.patch: OK
echo "30cec182a1437d40c3e0bd9a866ab5ddc1400a56185b7e671bb3782634ed0206 boost_test_impl_execution_monitor_ipp.patch" | sha256 -c

cd boost_1_64_0
patch -p0 < ../boost_test_impl_execution_monitor_ipp.patch
patch -p0 < ../boost_config_platform_bsd_hpp.patch

# Start building boost
echo 'using clang : : c++ : <cxxflags>"-fvisibility=hidden -fPIC" <linkflags>"" <archiver>"ar" <striper>"strip"  <ranlib>"ranlib" <rc>"" : ;' > user-config.jam
./bootstrap.sh --without-icu --with-libraries=chrono,filesystem,program_options,system,thread,test,date_time,regex,serialization,locale --with-toolset=clang
./b2 toolset=clang cxxflags="-stdlib=libc++" linkflags="-stdlib=libc++" -sICONV_PATH=/usr/local
doas ./b2 -d0 runtime-link=shared threadapi=pthread threading=multi link=static variant=release --layout=tagged --build-type=complete --user-config=user-config.jam -sNO_BZIP2=1 -sICONV_PATH=/usr/local --prefix=/usr/local install
Build the cppzmq bindings.
We assume you are compiling with a non-root user and you have doas enabled.
# Create cppzmq building directory
mkdir ~/cppzmq
cd ~/cppzmq

# Fetch cppzmq source
ftp -o cppzmq-4.2.3.tar.gz https://github.com/zeromq/cppzmq/archive/v4.2.3.tar.gz

# MUST output: (SHA256) cppzmq-4.2.3.tar.gz: OK
echo "3e6b57bf49115f4ae893b1ff7848ead7267013087dc7be1ab27636a97144d373 cppzmq-4.2.3.tar.gz" | sha256 -c
tar xfz cppzmq-4.2.3.tar.gz

# Start building cppzmq
cd cppzmq-4.2.3
mkdir build
cd build
cmake ..
doas make install
Build monero:
env DEVELOPER_LOCAL_TOOLS=1 BOOST_ROOT=/usr/local make release-static

OpenBSD >= 6.4

You will need to add a few packages to your system. pkg_add cmake gmake zeromq cppzmq libiconv boost.
The doxygen and graphviz packages are optional and require the xbase set.
Build monero: env DEVELOPER_LOCAL_TOOLS=1 BOOST_ROOT=/usr/local gmake release-static
Note: you may encounter the following error, when compiling the latest version of monero as a normal user:
LLVM ERROR: out of memory
c++: error: unable to execute command: Abort trap (core dumped)
Then you need to increase the data ulimit size to 2GB and try again: ulimit -d 2000000

On Solaris:

The default Solaris linker can’t be used, you have to install GNU ld, then run cmake manually with the path to your copy of GNU ld:
mkdir -p build/release
cd build/release
cmake -DCMAKE_LINKER=/path/to/ld -D CMAKE_BUILD_TYPE=Release ../..
cd ../..
Then you can run make as usual.

On Linux for Android (using docker):

# Build image (for ARM 32-bit)
docker build -f utils/build_scripts/android32.Dockerfile -t monero-android .
# Build image (for ARM 64-bit)
docker build -f utils/build_scripts/android64.Dockerfile -t monero-android .
# Create container
docker create -it --name monero-android monero-android bash
# Get binaries
docker cp monero-android:/src/build/release/bin .

Building portable statically linked binaries

By default, in either dynamically or statically linked builds, binaries target the specific host processor on which the build happens and are not portable to other processors. Portable binaries can be built using the following targets:
  • make release-static-linux-x86_64 builds binaries on Linux on x86_64 portable across POSIX systems on x86_64 processors
  • make release-static-linux-i686 builds binaries on Linux on x86_64 or i686 portable across POSIX systems on i686 processors
  • make release-static-linux-armv8 builds binaries on Linux portable across POSIX systems on armv8 processors
  • make release-static-linux-armv7 builds binaries on Linux portable across POSIX systems on armv7 processors
  • make release-static-linux-armv6 builds binaries on Linux portable across POSIX systems on armv6 processors
  • make release-static-win64 builds binaries on 64-bit Windows portable across 64-bit Windows systems
  • make release-static-win32 builds binaries on 64-bit or 32-bit Windows portable across 32-bit Windows systems

Cross Compiling

You can also cross-compile static binaries on Linux for Windows and macOS with the depends system.
  • make depends target=x86_64-linux-gnu for 64-bit linux binaries.
  • make depends target=x86_64-w64-mingw32 for 64-bit windows binaries.
    • Requires: python3 g++-mingw-w64-x86-64 wine1.6 bc
  • make depends target=x86_64-apple-darwin11 for macOS binaries.
    • Requires: cmake imagemagick libcap-dev librsvg2-bin libz-dev libbz2-dev libtiff-tools python-dev
  • make depends target=i686-linux-gnu for 32-bit linux binaries.
    • Requires: g++-multilib bc
  • make depends target=i686-w64-mingw32 for 32-bit windows binaries.
    • Requires: python3 g++-mingw-w64-i686
  • make depends target=arm-linux-gnueabihf for armv7 binaries.
    • Requires: g++-arm-linux-gnueabihf
  • make depends target=aarch64-linux-gnu for armv8 binaries.
    • Requires: g++-aarch64-linux-gnu
The required packages are the names for each toolchain on apt. Depending on your distro, they may have different names.
Using depends might also be easier to compile Monero on Windows than using MSYS. Activate Windows Subsystem for Linux (WSL) with a distro (for example Ubuntu), install the apt build-essentials and follow the depends steps as depicted above.
The produced binaries still link libc dynamically. If the binary is compiled on a current distribution, it might not run on an older distribution with an older installation of libc. Passing -DBACKCOMPAT=ON to cmake will make sure that the binary will run on systems having at least libc version 2.17.

Installing Monero from a package

DISCLAIMER: These packages are not part of this repository or maintained by this project’s contributors, and as such, do not go through the same review process to ensure their trustworthiness and security.
Packages are available for
  • Ubuntu and snap supported systems, via a community contributed build.
    snap install monero --beta
    
Installing a snap is very quick. Snaps are secure. They are isolated with all of their dependencies. Snaps also auto update when a new version is released.
  • Arch Linux (via AUR):
  • Void Linux:
    xbps-install -S monero
    
  • GuixSD
    guix package -i monero
    
  • Docker
    # Build using all available cores
    docker build -t monero .
        
    # or build using a specific number of cores (reduce RAM requirement)
    docker build --build-arg NPROC=1 -t monero .
        
    # either run in foreground
    docker run -it -v /monero/chain:/root/.bitmonero -v /monero/wallet:/wallet -p 18080:18080 monero
        
    # or in background
    docker run -it -d -v /monero/chain:/root/.bitmonero -v /monero/wallet:/wallet -p 18080:18080 monero
    
  • The build needs 3 GB space.
  • Wait one hour or more
Packaging for your favorite distribution would be a welcome contribution!

Running monerod

The build places the binary in bin/ sub-directory within the build directory from which cmake was invoked (repository root by default). To run in foreground:
./bin/monerod
To list all available options, run ./bin/monerod --help. Options can be specified either on the command line or in a configuration file passed by the --config-file argument. To specify an option in the configuration file, add a line with the syntax argumentname=value, where argumentname is the name of the argument without the leading dashes, for example log-level=1.
To run in background:
./bin/monerod --log-file monerod.log --detach
To run as a systemd service, copy monerod.service to /etc/systemd/system/ and monerod.conf to /etc/. The example service assumes that the user monero exists and its home is the data directory specified in the example config.
If you’re on Mac, you may need to add the --max-concurrency 1 option to monero-wallet-cli, and possibly monerod, if you get crashes refreshing.

Internationalization

See README.i18n.md.

Using Tor

There is a new, still experimental, integration with Tor. The feature allows connecting over IPv4 and Tor simulatenously - IPv4 is used for relaying blocks and relaying transactions received by peers whereas Tor is used solely for relaying transactions received over local RPC. This provides privacy and better protection against surrounding node (sybil) attacks.
While Monero isn’t made to integrate with Tor, it can be used wrapped with torsocks, by setting the following configuration parameters and environment variables:
  • --p2p-bind-ip 127.0.0.1 on the command line or p2p-bind-ip=127.0.0.1 in monerod.conf to disable listening for connections on external interfaces.
  • --no-igd on the command line or no-igd=1 in monerod.conf to disable IGD (UPnP port forwarding negotiation), which is pointless with Tor.
  • DNS_PUBLIC=tcp or DNS_PUBLIC=tcp://x.x.x.x where x.x.x.x is the IP of the desired DNS server, for DNS requests to go over TCP, so that they are routed through Tor. When IP is not specified, monerod uses the default list of servers defined in src/common/dns_utils.cpp.
  • TORSOCKS_ALLOW_INBOUND=1 to tell torsocks to allow monerod to bind to interfaces to accept connections from the wallet. On some Linux systems, torsocks allows binding to localhost by default, so setting this variable is only necessary to allow binding to local LAN/VPN interfaces to allow wallets to connect from remote hosts. On other systems, it may be needed for local wallets as well.
  • Do NOT pass --detach when running through torsocks with systemd, (see utils/systemd/monerod.service for details).
  • If you use the wallet with a Tor daemon via the loopback IP (eg, 127.0.0.1:9050), then use --untrusted-daemon unless it is your own hidden service.
Example command line to start monerod through Tor:
DNS_PUBLIC=tcp torsocks monerod --p2p-bind-ip 127.0.0.1 --no-igd

Using Tor on Tails

TAILS ships with a very restrictive set of firewall rules. Therefore, you need to add a rule to allow this connection too, in addition to telling torsocks to allow inbound connections. Full example:
sudo iptables -I OUTPUT 2 -p tcp -d 127.0.0.1 -m tcp --dport 18081 -j ACCEPT
DNS_PUBLIC=tcp torsocks ./monerod --p2p-bind-ip 127.0.0.1 --no-igd --rpc-bind-ip 127.0.0.1 \
    --data-dir /home/amnesia/Persistent/your/directory/to/the/blockchain

Debugging

This section contains general instructions for debugging failed installs or problems encountered with Monero. First, ensure you are running the latest version built from the Github repo.

Obtaining stack traces and core dumps on Unix systems

We generally use the tool gdb (GNU debugger) to provide stack trace functionality, and ulimit to provide core dumps in builds which crash or segfault.
  • To use gdb in order to obtain a stack trace for a build that has stalled:
Run the build.
Once it stalls, enter the following command:
gdb /path/to/monerod `pidof monerod`
Type thread apply all bt within gdb in order to obtain the stack trace
  • If however the core dumps or segfaults:
Enter ulimit -c unlimited on the command line to enable unlimited filesizes for core dumps
Enter echo core | sudo tee /proc/sys/kernel/core_pattern to stop cores from being hijacked by other tools
Run the build.
When it terminates with an output along the lines of “Segmentation fault (core dumped)”, there should be a core dump file in the same directory as monerod. It may be named just core, or core.xxxx with numbers appended.
You can now analyse this core dump with gdb as follows:
gdb /path/to/monerod /path/to/dumpfile`
Print the stack trace with bt

To run monero within gdb:

Type gdb /path/to/monerod
Pass command-line options with --args followed by the relevant arguments
Type run to run monerod

Analysing memory corruption

There are two tools available:

ASAN

Configure Monero with the -D SANITIZE=ON cmake flag, eg:
cd build/debug && cmake -D SANITIZE=ON -D CMAKE_BUILD_TYPE=Debug ../..
You can then run the monero tools normally. Performance will typically halve.

valgrind

Install valgrind and run as valgrind /path/to/monerod. It will be very slow.

LMDB

Instructions for debugging suspected blockchain corruption as per @HYC
There is an mdb_stat command in the LMDB source that can print statistics about the database but it’s not routinely built. This can be built with the following command:
cd ~/monero/external/db_drivers/liblmdb && make
The output of mdb_stat -ea <path to blockchain dir> will indicate inconsistencies in the blocks, block_heights and block_info table.
The output of mdb_dump -s blocks <path to blockchain dir> and mdb_dump -s block_info <path to blockchain dir> is useful for indicating whether blocks and block_info contain the same keys.
These records are dumped as hex data, where the first line is the key and the second line is the data.

FPGA@HOME BoInc GridCoin Clusters



Needed FPGA Hardware Modifications





Currently, the Bittware cards (CVP-13, XUPVV4) do not require any modifications and will run at full speed out-of-the-box.

If you have a VCU1525 or BCU1525, you should acquire a DC1613A USB dongle to change the core voltage.

This dongle requires modifications to ‘fit’ into the connector on the VCU1525 or BCU1525.

You can make the modifications yourself as described here,

You can purchase buy a fully modified DC1613A from https://shop.fpga.guide.

If you have an Avnet AES-KU040 and you are brave enough to make the complex modifications to run at full hash rate, you can download the modification guide right here (it will be online in a few days).  You can see a video of the modded card On YouTube: Here.

If you have a VCU1525 or BCU1525, we recommend using the TUL Water Block (this water block was designed by TUL, the company that designed the VCU/BCU cards).

The water block can be purchased from https://shop.fpga.guide.






















WARNING:  Installation of the water block requires a full disassembly of the FPGA card which may void your warranty.

Maximum hash rate (even beyond water-cooling) is achieved by immersion cooling, immersing the card in a non-conductive fluid.

Engineering Fluids makes BC-888 and EC-100 fluids which are non-boiling and easy to use at home. You can buy them here.

If you have a stock VCU1525, there is a danger of the power regulators failing from overheating, even if the FPGA is very cool.

 We recommend a simple modification to cool the power regulators by more than 10C.  The modification is very simple. You need:
First, cut a piece of thermal tape and apply it to the back side of the Slim X3 CPU cooler, and plug the fan into the fan controller:



Then, you are going to stick the CPU cooler on the back plate of the VCU1525 on this area:


Once done it will look like this:


Make sure to connect the fan controller to the power supply and run the fan on maximum speed.  This modification will cool the regulators on the back side of the VCU1525, dropping their temperature by more than 10C and extending the life of your hardware.  This modification is not needed on ‘newer’ versions of the hardware such as the XBB1525 or BCU1525.


Monero-(XMR) 4X_XCVU440-FPGAs 120+ G/hs


UltraScale Prototyping System



Technical highlights

  • Scaleable up to 120 M ASIC gates capacity on one board
  • Modular with up to 4 x Xilinx Virtex® XCVU440 FPGAs
  • Up to 5308 signals for I/O and inter FPGA connection
  • Up to 40 individually adjustable voltage regions
  • Up to 1.0 Gbps single ended point to point speed

Further information on UltraScale Prototyping System and related links

UltraScale Prototyping System

Product Summary
UltraScale Prototyping System - The proFPGA quad VUS 440 system is a complete and modular multi FPGA solution, which meets highest requirements in the area of FPGA based Prototyping. It addresses customers who need a scalable and flexible high speed ASIC Prototyping solution for early software development and real time system verification. The innovative system concept offers highest flexibility and reusability, reconfigurability for several projects, which guarantees the best return on invest.rn on invest.
Highest Flexibility
The system architecture is based on a modular and scalable system concept. The FPGAs are assembled on dedicated FPGA modules, which will be plugged on the proFPGA uno, duo or quad mother board. This offers the highest flexibility to use for example different FPGA types in one system or to scale a system in increments of one FPGA. The user has nearly 100% access to all available I/Os of the FPGA, which gives him maximum freedom regarding the FPGA inter connection structure. This way the prototyping system can be adapted in the best way to any user design. Furthermore the system offers a total of 40 extension sites on the top and bottom site for standard proFPGA or user specific extension boards like DDR-4 memory, PCIe gen1/2/3, Gigabit Ethernet, USB 3.0 or other high performance interface and interconnection boards.
Maximum Performance
The well designed boards of the proFPGA system are optimized and trimmed to guarantee best signal integrity and to achieve highest performance. The high speed boards together with specific high speed connectors allow a maximum point to point speed of up to 1.0 Gbps single ended over the standard FPGA I/O and up to 12.5 Gbps differential over the high speed serial transceivers of the FPGA. This performance combined with the high interconnection flexibility allows the designer to run his design at maximum speed in the proFPGA system.
Big Capacity
Equipped with up to 4 Xilinx Virtex® UltraScale™ 440 FPGA modules, the proFPGA quad system can handle up to 120 M ASIC gates on only one board. Due to the fact, that multiple proFPGA quad or duo systems can be connected to an even larger system, there is an unli- mited scalability and no theoretical maximum in capacity.
Very User Friendly
The proFPGA prototyping system provides an extensive set of features and tools, like remote system configuration, integrated self and performance test, automatic board detection, automatic I/O voltage programming, system scan and safety mechanism, which simplifies the usage of the FPGA based system tremendously.

Thursday, July 25, 2019

Bitcoin Gold (BTG): Cryptocurrency

Bitcoin Gold (BTG)




Bitcoin Gold (BTG)


Bitcoin Gold (BTG) is a hard fork of Bitcoin (BTC) and shares the same transaction history up to the point of the fork. The Bitcoin Gold hard fork took place on October 24, 2017. The stated purpose of the fork is to restore GPU mining functionality to Bitcoin, as opposed to specialized ASICs.
See also: Bitcoin (BTC) (basic) - Fork, Soft fork, Hard fork & Coin split 
 (advanced), Supported cryptocurrencies

: Cryptocurrency

Offloading CPU-2-FPGA: Cryptocurrency


Offloading CPU-2-FPGA

Offloading CPU-2-FPGA: The fully verified and tested CPU and-or GPU offload systems is PRO DESIGNs modular and scalable high performance multi FPGA Prototyping solutions. Scalable from 1 up to 4 pluggable Xilinx Virtex® UltraScale™ XCVU440 based FPGA modules the QUAD system offers a capacity of up to 120 M ASIC gates, which is nearly a factor of 2.5 more compared to the previous Virtex® 7 based generation. Up to five proFPGA QUAD systems with overall 20 FPGA modules can be easily connected together to increase the capacity up to 600 M ASIC gates.

Offloading CPU-2-FPGA: PRO DESIGN, veteran in the E²MS and EDA industry, who announced a Xilinx Virtex® UltraScale™ XCVU440 FPGA Prototyping solution is launched. The complete proFPGA product family consisting of the proFPGA UNO, DUO and QUAD system, based on the latest FPGA technology at the Design Automation.




BTC









 5G Baseband for L1 Offloading.



Key Zynq UltraScale+ RFSoC Portfolio Benefits: 
  • Integrated Soft-Decision Forward Error Correction (SD-FEC) cores
  • LDPC codec (SD-FEC) to meet 5G standards and support for custom codes
  • Turbo Decode (SD-FEC) for 4G LTE-Advanced and 4G LTE Pro
  • DSP48-rich fabric (6,620 GMACs) provides high-performance filtering and encoding/decoding
  • 33 Gb/s transceivers for 12.2G CPRI and expansion into 16G & 25G CPRI













Hardware programming for software developers:
Several  disrupting factors in the traditional microprocessors being the chip of choice for C-Programming algorithms. 

These include cost and accessibility of cross-compilation tools, the processing power, the speed limitations of microprocessors, and the availability of more reliable building blocks.

These are three university individual researchers breaking down the problem into understandable laymen step-by-step the average developer can follow to determine if FPGAs are worth the bother.

This is based on hundreds of hours of class and lab testing.

These authors are willing to share their instructional materials, curricula, and advice for the readers here.

Problem identification:
Microprocessors continue to represent the largest "bang for the buck" and are at the center of most systems.

FPGAs are semi-custom, co-processing resource that is "picking off" the parallelization tasks from CPUs. FPGAs do this – at lower clock speeds and power – by deploying multi-core parallelism.</p>

HPRC:
High Performance Reconfigurable Computing (HPRC) as a branch of Computer Science is thriving.

HPRC Largely driven by GPGPU (general-purpose graphics processing unit) growth, HPRC is also supported by FPGA-based applications.

The programming environment is considered to be the main obstacle preventing FPGAs from being used to their full potential in accelerators. Thus, the need to gain familiarity with High Level Languages (HLLs) is inevitable.

A high-level language (HLL) is a programming language such as C, FORTRAN, or Pascal that enables a programmer to write programs that are more or less independent of a particular type of computer. Such languages are considered high-level because they are closer to human languages and further from machine languages.
 

Architectural differences in C for FPGAs vs. C for CPUs:
The C language that is refactored for FPGA, can be characterized as a stream-oriented programming language, and process-based language.

Processes are organized into main building blocks interconnected using streams to form the architecture for the desired hardware module.

From a hardware perspective, processes and streams are hardware modules and FIFOs (First In, First Out registers) respectively.

The C programming model is generally based on the Communicating Sequential Processes model.

Every process must be classified as a hardware or a software process. It is the programmer's responsibility to ensure inter-process synchronization.

Like all human readable HLLs, C does not provide access to the clock signal, which relieves the designer from implementing cycle synchronization procedures.

Understand, it is possible to attach HDL modules and synchronize them at the RTL, (Real Time Level), using clock signals. It is worth noting that C as a hardware design language does not permit dynamic resource allocation (e.g., "malloc()" and "calloc()").

The second unique language construct, besides being process-oriented, is stream orientation. Streams are unidirectional and can interconnect only two processes, which imposes restrictions on hardware module architectures designed in C.

Since pipelines can become a source of deadlocks, the designer particularly needs to consider mechanisms to avoid them. Unfortunately, occurrences of deadlocks are difficult to trace during simulations since the "#pragma co pipeline" C-to-HDL compiler directive is ignored during software simulation.

These problems are usually revealed after implementation when the module is tested in hardware.

In addition to streams and processes, C as a design method provides signals and semaphores. These structures are used for inter-process synchronization. The best practice is often to implement pure pipeline modules, with the lowest possible number of synchronization signals.

Software processes are converted to multiple streaming
hardware processes where they use streams,
signals, or memory for synchronization.

Methodology:
HLLs are used for purposes of data type flexibility in terms of HDL module integration use.

Typically, there will be a range of data structures available such as co_int2, co_int32, co_uint1, co_uint32, etc.

These constructs are also a source of inconsistency between the software and hardware implementations.

Prior to FPGA implementation, all hardware modules should be simulated on a GPP (general purpose processor) where their data structures are mapped on the types available on the GPP.

Unfortunately GPPs use limited sets of data types, so each time a simulation is performed, the data is extended to the nearest wider data type, which affects intrinsic computation precision.

This occurs unless a dedicated macro is used (e.g. "UADD4()" and "UDIV20()"); thus, using macros is encouraged.

Special attention must be paid to functions, since they highly simplify modular implementation, since this is the common design strategy.

The following pragmas are useful: "co inline," "co implementation," "co unroll," "co pipeline," and "co set."

These allow module shaping, providing a set of restrictions. By example, using "inline" in a function body enables the compiler to freely modify the internal architecture of the module.

if not implimented, the function is treated as a uniform module, which cannot be modified by the compiler.

Static recurrence is permitted and proves to be a useful structure in many applications such as a binary tree implementation with the "add_tree()" command is needed.

The limitations of using C for hardware result mostly from the exceptions of the adaptation of ANSI C to hardware design. Notable examples include:

  • Lack of dynamic recurrence
  • No support for unions
  • Dynamic memory allocation is unsupported (free(), malloc()) in hardware
  • Limited support of pointers
  • A pointer may only point to one block of memory
  • Pointers must be determined at compilation time

Several techniques to optimize performance of the implemented hardware modules that may work.

Reading and writing to streams can be implemented in several ways and one is to provide an efficiant pipeline performance (1 cycle per single operation).

Data access conflicts may also contribute to significant reduction of expected performance. A solutions, is important to  debug such conflicts by memory duplication or multi-object-optimization by table scalarization (using the "co_array_config()" instruction).

The number of combination logic levels should be kept reasonably low, which can be achieved with a single pragma parameter (e.g., "co set Stage Delay 32").

Stage Delay Analysis provides the tools needed to see
how decisions made in C algorithms will propagate
in logic and clock cycles.


As a general rule, it is recommended to use appropriate data structures to maximize data throughput.

The C-to-FGPA IDE delivers a range of tools which facilitate flexable debugging.

One convenient tool is the Stage Master Explorer (SME), which may be used to examine code and pinpoint throughput bottlenecks.

The measured performance in the SME is expressed through a set of four parameters, which characterize the digital module: Latency, Rate, Max. Unit Delay, and Effective Rate.

Two simple teaching examples:

1.) Implementation of an FPGA-accelerated HASH function using C:
In this exercise exampled below, the programmer's, task was to implement a hash function in C.

The algorithm could not be implemented in a naive way (by copying and pasting it inside the hardware main function body), but it had to be re-coded and optimized as hardware.

The first step was to run a given hash function on a GPP to produce a reference output for the given input.

The reference code in ANSI-C is shown below.

Every student-programmer had this same input vector, but different functions, preventing plagiarism. Such solutions have the additional advantage of verifying if the whole solution is correct.

To do so, a programmer must only check the correctness of one output number.


Noted that the interface between the CPU and FPGA is 32 bits wide, and equates to four-bytes of data is transferred at once to the hardware module to minimize bottleneck via system throughput.

The programmers results differed in quality, but the best ones used pipelined operations, which resulted in a high throughput with slightly higher latency than for non-pipelined cases programming solutions.

A few student-programmers unrolled an internal for loop using the pragma "CO UNROLL" directive.

By using pipelined operations, they reduced the hashing function execution time N times and increased output N times. The disadvantage of such an approach was the high usage of available logic resources for high over-all data-flow.

#2 A Prime Number Generator using C:
Another tutorial began by asking student-programmers to find algorithms in literature used as Prime Number Generators (PNGs).

This knowledge was used during the following hands-on exercises.

The students also had to write their own module(s) in VHDL, which were used in the PNG.

The module could be a trivial one but – if so – the number had to be greater than one (e.g., the operation of square and incrementation by constant factor).

The modules had to be 100% compatible with the C external module standards and verified as accurate in a test-bench.

The students got their guidelines about the communication interface connecting the CPU and FPGA (using a 32-bit bus) and software design was a user interface that collects information regarding the lower and upper bounds between which the prime numbers had to be found.

This information had to be sent to the hardware module using a stream, after which the hardware process started to run. The algorithms selected by student-programmers generated proper primes and sent them to the software application, whose role was to present these results on-screen and write them into a text file.

PNG was used as an example for two reasons:

  • It is hard to write such a function in pure VHDL, which makes the advantages of C more visible
  • Every algorithm that can be used to generate primes is composed of many operations. Therefore it is easier to pick one and implement it in VHDL, avoiding duplication across students within the same group.

Some students decided to implement PNG in naive way using algorithms called trial division; that is, by checking if a number can be divided, without a remainder, only by itself. As a "reward," they had to implement some "nasty" operation in VHDL, like a modulus or a square root. Many students decided to use the Sieve of Eratosthenes; a few students decided to use the "Fermat's 4k+1" and "Euler's 6k+1" algorithms to check if a number is a prime. The best method was one proposed by student Grzegorz Glowka BSc due to its adaptation of all three previously mentioned algorithms. Student Glowka observed that -- in some intervals -- some methods are more efficient than others, and he implemented his PNG in such a manner as to leverage this fact.

The lessons from the exercise were as follows:

  • Implement everything in C and perform software simulations, then run working applications and tests that measure their performance in the hardware
  • Find weaknesses of C-to-HDL translation and eliminate them by replacing them with regards to HDL blocks. Regenerate the whole design, implement it in hardware, and then run tests and measure their performance.
  • Consider rewriting key elements in HDL to tune performance.
  • Rewrite the whole hardware part into HDL, or only those parts that are responsible for data processing, leaving C to interface and transmit data, etc.

Results:

Since we are teachers, our students are our "results."
We are happy to report that both their grades were up (from prior years of similar coursework) and that students felt a little more prepared for corporate life with more hands-on method of approach.

The class continues to develop as the institution frame-work provides.

Acknowledgments:
The authors would like to acknowledge the assistance given by Brian Durwood of Impulse Accelerated Technologies in the preparation of this article.

About the authorsGrzegorz Gancarczyk was born in Nowy Sacz, Poland, in 1984. He received an MSc degree in the field of electronics from the AGH University of Science and Technology (AGH-UST), Krakow, Poland, in 2009.

Since 2009, he is with the Academic Computer Centre (ACC) CYFRONET AGH, Krakow, Poland and now also with the Department of Electronics, AGH-UST, Krakow, Poland. His research interests include engineering education, statistics, stochastic processes, phenomenon of noise, digital signal processing and hardware acceleration of numerical methods. You can contact Grzegorz at gegula@agh.edu.pl

Maciej Wielgosz was born in Krakow, Poland, in 1979. He received his MSc and PhD degrees in the field of electronics from the AGH-UST, Krakow, Poland, in 2005 and 2010, respectively.

Since 2005, he is with the ACC CYFRONET AGH, Krakow, Poland and since 2009 also with the Dept. of Electr., AGH-UST, Krakow, Poland. He has published over 40 papers in journals and conferences and also one book: "FPGA implementation of the selected floating point operations" (Warszawa: Akademicka Oficyna Wydawnicza EXIT, 2010). His research interests include educational issues in electronics, data compression, neural networks and hardware acceleration of computations. You can contact Maciej at wielgosz@agh.edu.pl

Kazimierz Wiatr was born in Tarnow, Poland, in 1955. He received MSc and PhD degrees in the field of electrical engineering from the AGH-UST, Krakow, Poland, in 1980 and 1987, respectively, D. Hab. (habilitation) degree in electronics from the University of Technology of Lodz, Lodz, Poland, in 1999. Professor degree in 2002.

Since 1980, he works at the Dept. of Electr., AGH-UST, Krakow, Poland. Head of Reconfigurable Computing Systems Group. Since 2004 director of the ACC CYFRONET AGH. Since 2006 chairman of the board of PIONIER - Polish Optical Internet - Consortium. Between 1998 and 2002 adviser to the Prime Minister of Poland on "educational and upbringing of the young generation".

Managed 9 Polish Scientific Research Committee research grants. His works resulted in over 200 publications, 19 books, 5 patents and 35 industrial implementations.

Achieved Polish Science and Higher Education Minister's Award. Has been involved with youth education for more than 30 years. One of the founders of the Polish independent scouting movement. His research interests include educational issues, processes automation, image systems, multiprocessor and many core systems, reconfigurable devices and hardware methods of calculations accelerating.

Prof. Wiatr was appointed in 2007 to a chairman of Tarnow Scientific Society. Member of the Polish Information Processing Society, European Organization for Information and Microelectronics (EUROMICRO). In the Sixth and Seventh Term Senate was a chairman of the Science, Educational and Sport Committee.

Reviewer in the IEEE Expert Magazine, IEE Computer and Digital Techniques, IEE Electronic Letters, IEEE Transactions on Neural Networks, Eurasip Journal on Applied Signal Processing, Journal Machine Graphics and Vision. Prof. Wiatr can be contacted at wiatr@agh.edu.pl



If you found this article to be of interest, visit Programmable Logic Designline where – in addition to my Max's Cool Beans blogs – you will find the latest and greatest design, technology, product, and news articles with regard to programmable logic devices of every flavor and size (FPGAs, CPLDs, CSSPs, PSoCs...).

Also, you can obtain a highlights update delivered directly to your inbox by signing up for my weekly newsletter – just Click Here to request this newsletter using the Manage Newsletters tab (if you aren't already a member you'll be asked to register, but it's free and painless so don't let that stop you [grin]).



OptEdit Article Domain-Source


 Offloading CPU To FPGA Article ends here:
Door-closes session class over!