❌ About FreshRSS

Reading view

There are new articles available, click to refresh the page.

AArch64 cross toolchain

The community has long expressed interest in supporting Ada on ARM64 and Apple Silicon platforms. Unfortunately, GitHub Action Runners are not available for ARM for open-source projects. The publication of the Ada extension for VS Code (as well as Alire) relies on GitHub Actions, limiting ARM support. However, it turns out that creating an ARM version is still possible, and I’d like to share my experience with using cross-compilers for this purpose.

Through the actions described below, I managed to obtain two cross-compilers for the aarch64 CPU (running on x86_64), one for Linux and the other for macOS. These proved sufficient to build ALS and VSCode extensions for these platforms.

I began by building the Ada Language Server version for ARM64/Linux since this platform is more familiar to me. Ubuntu provides cross-versions of dependencies for GNAT (glibc, binutils). Ubuntu even has GNAT GCC 13, but on newer versions than the one (20.04) we use for ALS building. The first thing I did was attempt to rebuild GCC 13 on Ubuntu 20.04 from the source package of the latest Ubuntu distribution (23.10). Although this might be the most correct method from a reuse perspective, it didn’t suit me - too many packages and installation steps.

Building GNAT from the GCC 13 source texts proved much simpler. The resulting script was just a dozen lines long.

If you unpack the resulting archive in /, gprbuild finds the cross-compiler and using it subsequently is straightforward: you just need to specify the option --target=aarch64-linux.

Mac OS also provides cross-versions of binutils and libc, which come with the standard installation of Xcode Command Line Tools. For example, /usr/bin/as can create object files for both x86_64 and aarch64, depending on the --target. Therefore, we only need to build GNAT using the GCC sources from the repository iains/gcc-13-branch.

If you need binaries for these cross-compilers or have ideas on how to use them, please leave a comment in this thread.

PS Thanks to Simon Wright for experimenting with Mac OS and providing advices.

2 posts - 2 participants

Read full topic

Machine learning in Ada (an ONNX runtime binding)

As an Ada enthusiast, I’ve always wanted to try my hand at machine learning, but was discouraged by the fact that Python seemed to be the only language supported by most ML frameworks. However, I recently discovered the Open Neural Network Exchange (ONNX) format, a universal way of representing machine learning models, and a library for working with it. One thing I love about ONNX is that there are many pre-trained models available for various applications.

I was excited to find out that I could use Ada to load and make inference with ONNX models, so I created a binding for the ONNX Runtime library and wrote a couple of example programs. These examples include handwriting digit recognition and English speech synthesis. Unfortunately, the speech synthesis example required converting text to phoneme sequences, which I haven’t yet implemented in Ada, in order to keep the examples compact.

Overall, I’m thrilled to have been able to dive into the world of machine learning using my favorite programming language, and I hope that other Ada enthusiasts will find this information useful. If anyone is interested in trying it out for themselves, I’m happy to share my code and provide more information on how to get started with Ada and ONNX.

5 posts - 3 participants

Read full topic

Enabling code navigation on GitLab

GitLab is a repository management system for storing software source code, you might say an analogue of GitHub. While the core features of GitLab are comparable to its counterparts, some implementation features can be useful for the Ada community. One of them is the code navigation directly on the repository site. GitLab understands (let’s face it, not very well) semantic information about the program in LSIF (Language Server Index Format) format, which allows you to enable code navigation, tooltips, etc. for any language. GitLab counterparts now only offer navigation support for a limited range of languages.

Having code navigation on your site is nice and makes it easier to get to know your code and conduct code reviews. To enable it in your repository, simply create a CI Pipeline which indexes the source code after changes and uploads the result as a special type of artifact. The prototype indexer program is already ready, it’s not hard to build with Alire. I prepared a script, which can be run with a one-liner:

curl -fsSL https://raw.githubusercontent.com/reznikmm/als-alire-index/main/make_lsif.sh | bash

To avoid having to build the indexer program every time you change it, you can add it directly to the image used by the pipeline, together with the compiler and alire. This is what the Dockerfile looks like:

FROM ubuntu:22.04
RUN apt-get update \
 && DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends -y \
      python3 curl unzip git libgmp-dev libc6-dev make python3-pip python3-venv \
 && curl -fsSL https://raw.githubusercontent.com/reznikmm/als-alire-index/main/make_lsif.sh | bash \
 && mv -v alr lsif-ada /bin/ \
 && apt-get purge -y --auto-remove python3 python3-pip python3-venv \
 && apt-get clean \
 && rm -rf /var/lib/apt/lists/* /root/clean

I put the pushed image on the Docker Hub as reznik/gnat:alire and it can be used in any repository. As an example, I’ve enabled navigation in my TLS repository. You can now see where any identifier is defined with the mouse pointer.

defname

Would you like to give it a try?

3 posts - 2 participants

Read full topic

❌