Mathieu GAILLARD

Cross compilation from Ubuntu 24.04 to Windows 98

Thu, 16 Jul 2026 10:37:00 -0700

I recently discovered that despite being a very old 32-bits operating system, it’s still possible to cross compile programs from a recent Linux distribution to Windows 98!

The program

I wrote a very small program for this example. It prints Hello World! and a randomly generated number. Even if the toolchain supports C11, I decided that it would be more fun to write ANSI C, which was the standard at that time. The reason I didn’t use C++ is because Microsoft Visual C++ 6.0 could do C++, but it is not the standardized C++98.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void)
{
    int seed;

    printf("Hello World!\n");

    seed = (int)time(NULL);
    srand((unsigned int)seed);

    printf("Random number: %d\n", rand());

    return EXIT_SUCCESS;
}

How to build

On Ubuntu 24.04, you need to install the following package that contains the necessary toolchain.

sudo apt install gcc-mingw-w64-i686-win32

Then you can use this Makefile to build for Windows 98. Note that since that my CPU is a Pentium III with MMX and SSE, I activated the instructions with -march=pentium3 -mmmx -msse. For maximal compatibility, you could remove these flags.

# Makefile — cross-compile ANSI C to Windows 98 console program
# Compiler: i686-w64-mingw32-gcc (MinGW-w64 targeting 32-bit Win32)

CC      := i686-w64-mingw32-gcc
CFLAGS  := -std=c89 -pedantic -Wall -Wextra -Werror -march=pentium3 -mmmx -msse
LDFLAGS :=

TARGET  := hello.exe
SRC     := main.c

.PHONY: all clean

all: $(TARGET)

$(TARGET): $(SRC)
	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<

clean:
	rm -f $(TARGET)

It runs!

This is a screenshot that I took on my Windows 98 laptop, a Dell Latitude C610 with a Pentium III. It works flawlessly!

Conclusion

This was of course just a quick test. I’m sure we can do more than just a Hello World program. Being able to use modern computers to write code for Windows 98 speeds up things considerably.

Using an SQL database as a job queue

Sun, 01 Dec 2024 18:30:00 -0800

I recently discovered that relational databases can be used as a job queue. For some reason, I thought it was not possible, and tools like RabbitMQ, Apache Kafka, Redis, Amazon SQS, were the only options for dispatching jobs from a set of producers to a set of consumers.

Don’t get me wrong, these special tools are probably better than a relational database in some cases, and they do solve real problems. But what if you already have a relational database in your IT system, and you need to implement a job queue? Wouldn’t it be nice to reuse an existing component and save on additional operational costs? I think that if scalability is not a concern, and all you need is to process long running jobs, a relational database is probably just enough.

In this article, I will show you one feature from SQL that can be use to implement a job queuing system.

PostgreSQL’s features for job queues

PostgreSQL provides two features that can be used for queuing jobs.

First, a SELECT statement with the FOR UPDATE SKIP LOCKED option will ensure that a lock is acquired for all rows that are selected, and rows that were already locked cannot be selected again. This ensures that a job is selected and processed only once.

Second, the LISTEN and NOTIFY statements can be used to push events to the workers that will process jobs. This way, you do not have to implement a polling mechanism, you can directly notify your workers when a new job is added to the queue.

An example implementation

In the rest of this article, I will show you a prototype of a job queue implemented with PostgreSQL. Producers and consumers for the queue will be implemented in Python, and will be responsible respectively for adding jobs, or processing them.

Installation

In this section, I assume that you are starting from a base Ubuntu 24.04 instance.

First, we setup Python to be able to connect to a PostgreSQL database.

sudo apt install python3 python3-venv
# Create the virtual environment
python3 -m venv venv
source venv/bin/activate
# Install the PIP package for PostgreSQL
pip install "psycopg[binary,pool]"

Then, we install PostgreSQL locally.

sudo apt install postgresql
# No need to configure remote connections if we use the server locally.
# However, we do need to change the password for the default user.
sudo -u postgres psql template1
# Type this in the postgres prompt
ALTER USER postgres with encrypted password 'your_password';
# Then type \q to quit
\q
# Reboot the PostgreSQL server to take in account the new configuration
sudo systemctl restart postgresql.service

Database creation

We will use the PostgreSQL CLI tool to create the table that will contain the jobs that our system needs to process.

Each job will have:

A unique ID, that is auto incrementing primary key
A status, which is either 0 when the job is pending, or 1 when it’s done
A result, which is 0 by default, and contains the result after processing

To add the table, we first connect in CLI to the database.

# We connect to the default database template1
sudo -u postgres psql template1

With the SQL prompt, we create the table by typing the following.

CREATE TABLE jobs (
    id SERIAL PRIMARY KEY,
    status SMALLINT,
    result INTEGER
);

CREATE INDEX idx_status ON jobs (status);

Job producer

A python script will be responsible for adding N jobs to the queue. It will add one job every 50 milliseconds until all jobs are added.

#! /usr/bin/env python
import argparse
import psycopg
from time import sleep

class JobProducer:
    def __init__(self):
        self.connection = None

    def __del__(self):
        if self.connection is not None:
            self.connection.close()

    def connect(self):
        """ Connect to the postgres DB """
        try:
            self.connection = psycopg.connect(
                dbname="template1",
                user="postgres",
                password="your_password",
                host="localhost",
                port="5432"
            )
        except (Exception, psycopg.DatabaseError) as error:
            print(f"Error during connection: {error}")
    
    def disconnect(self):
        """ Disconnect from the postgres DB """
        if self.connection is not None:
            self.connection.close()
            self.connection = None

    def insert_new_job(self):
        """ Insert a job in the database """
        if self.connection is None:
            raise RuntimeError("You need to be connected before you can insert jobs.")

        try:
            cursor = self.connection.cursor()
            insert_query = "INSERT INTO jobs (status, result) VALUES (%s, %s)"
            data_to_insert = ('0', '0')
            cursor.execute(insert_query, data_to_insert)
            self.connection.commit()
        except (Exception, psycopg.DatabaseError) as error:
            print(f"Error during insertion: {error}")
        finally:
            cursor.close()


def run_job_producer(number_jobs, per_job_delay):
    job_producer = JobProducer()
    job_producer.connect()
    for i in range(number_jobs):
        job_producer.insert_new_job()
        print("Added a job!")
        sleep(per_job_delay)
    job_producer.disconnect()


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("N", help="Number of jobs to add to the queue", type=int)
    args = parser.parse_args()

    if args.N <= 0:
        raise ValueError("The number of jobs to add must be positive.")

    run_job_producer(args.N, per_job_delay=0.1)

Job consumers

Another python script will be responsible for processing jobs. The task of a job processor is to hold the job for 100 milliseconds, add a given number to its result, and set it as processed. If no job is available in the queue, the worker waits for 10 milliseconds. We will launch multiple instances of the job processor with different input parameters so that we can easily infer which processor processed which job.

#! /usr/bin/env python
import argparse
import psycopg
from time import sleep

class JobConsumer:
    def __init__(self):
        self.connection = None

    def __del__(self):
        if self.connection is not None:
            self.connection.close()

    def connect(self):
        """ Connect to the postgres DB """
        try:
            self.connection = psycopg.connect(
                dbname="template1",
                user="postgres",
                password="your_password",
                host="localhost",
                port="5432"
            )
        except (Exception, psycopg.DatabaseError) as error:
            print(f"Error during connection: {error}")
    
    def disconnect(self):
        """ Disconnect from the postgres DB """
        if self.connection is not None:
            self.connection.close()
            self.connection = None

    def try_to_process_a_job(self, per_job_delay, add_to_results):
        """ Try to process a job """
        if self.connection is None:
            raise RuntimeError("You need to be connected before you can process jobs.")

        try:
            # Start a transaction
            cursor = self.connection.cursor()
            
            # Select one pending job in the queue
            select_query = """
                SELECT id, result
                FROM jobs 
                WHERE status = 0
                FOR UPDATE SKIP LOCKED
                LIMIT 1
            """
            cursor.execute(select_query)
            job = cursor.fetchone()
            
            # If a job is available
            if job:
                job_id, job_result = job[0], job[1]
                print("Selected Job: ", job_id)

                # Compute the value of the new result
                new_result = job_result + add_to_results

                # Sleep to simulate the time it takes to process a job
                sleep(per_job_delay)
                
                # Define the update query to set the job as processed and update its result
                update_query = """
                    UPDATE jobs
                    SET status = 1, result = %s
                    WHERE id = %s
                """
                cursor.execute(update_query, (new_result, job_id))
                
                # Commit the transaction
                self.connection.commit()
                print("\tJob processed successfully")
            else:
                # No job is available
                self.connection.rollback()
        except (Exception, psycopg.DatabaseError) as error:
            print(f"Error during processing: {error}")
        finally:
            cursor.close()


def run_job_consumer(
        number_job_processing_attempts,
        polling_delay,
        per_job_delay,
        add_to_results):
    job_consumer = JobConsumer()
    job_consumer.connect()
    for i in range(number_job_processing_attempts):
        job_consumer.try_to_process_a_job(per_job_delay, add_to_results)
        sleep(polling_delay)
    job_consumer.disconnect()


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("N", help="Number to add to job results", type=int)
    args = parser.parse_args()

    number_job_processing_attempts = 5000
    polling_delay = 0.01
    per_job_delay = 0.1

    run_job_consumer(
        number_job_processing_attempts,
        polling_delay,
        per_job_delay,
        args.N
    )

Validation

When the whole job queue is processed, we will try to detect jobs that were potentially processed twice by looking at their results. If any result contains a number that is a composition of any input parameters, it means that the job was processed at least twice.

For example, if two job processors were launched with input parameters 1 and 10, then if any job has an assigned result of 11, it means that this job has been processed by both workers 1 and 2, which is an error.

To validate, we count any job whose result is not one of the input parameters to the consumers. If everything went well, this value should be 0. For example, this is the expect result in the SQL prompt.

template1=# SELECT COUNT(*) FROM jobs WHERE result != 1 AND result != 10;

count 
-------
     0
(1 row)

Launching the scripts

We first launch all consumers, then we launch the producer. We wait until all jobs have been processed. Finally, we check results with the SQL command that counts results. In one terminal, we would do it this way.

python consumer.py 1 &
python consumer.py 10 &
python producer.py 1000

This image shows how it looks like when I run it in VS Code:

Conclusion

In this article, I showed that PostgreSQL is a valid alternative to task queues. In particular, this solution is compelling when the system does not need to handle a large load, and PostgreSQL is already available. Although, the solution that I described works, it is based on polling. In a future work, we may investigate the use of two features from PostgreSQL that may be useful to implement. First, PostgreSQL’s LISTEN/NOTIFY mechanism can be used to implement a publish/subscribe pattern, which may be preferable compared to polling. Second, PostgreSQL can be used for distributed locking using advisory locks.

References

Calling printf in NASM assembly on Linux

Fri, 20 Sep 2024 13:30:00 -0700

Recently I was trying to print a number in x86_64 assembly on Linux with NASM, and it took me quite some time to figure out how to do it correctly. In this article I will share my solution with you, together with some explanations.

Printing Hello World!

This is the file main.asm, which contains the main function of our program.

BITS 64;

        global    main                  ; the standard gcc entry point
        extern printf                   ; declare a C function to be called

        section   .text
main:   
        push        rbp                 ; set up stack frame, must be alligned
        mov         rdi, message        ; first argument for printf
        xor         rax, rax            ; rax must be 0 (see explanations below)
        call        printf              ; call the printf function
        pop         rbp                 ; restore stack
        mov         rax, 0              ; normal, no error, return value
        ret                             ; return

        section   .data
message:  db "Hello, World!", 10, 0     ; note the newline (10) and null (0) at the end

This Makefile will compile and link our NASM program.

all: main

main: main.o
	gcc -m64 -o main main.o -lc -no-pie

main.o: main.asm
	nasm -f elf64 -o main.o main.asm

clean:
	rm -f main.o

To build and call the program:

$ make
$ ./main
# Hello World!

Explanations

The first line: BITS 64; tells NASM that we are running on a 64 bits architecture. It prevents a number of syntax highlight errors in VS Code.

Because we are linking with gcc, and not ld, the entry point is not _start but main like the int main() function in C. Therefore, we declare our main function with global main, we setup the stack frame with push rbp and pop rbp, and we return zero with mov rax, 0 and ret.

Calling printf() is done like in C. The first argument is a pointer to the null terminated string "Hello, World!\n", so we set it with mov rdi, message. According to the calling convention on Linux for functions with variable arguments, the register RAX contains the number of vector register arguments. Since we do not pass any floating-point numbers, RAX must be equal to zero. We reset it with xor rax, rax.

When linking with gcc, the option -no-pie is used in order to prevent a linking error about position independent executables. And the option -lc tells gcc to link with the C library.

Printing a number

If we wanted to print a number like this printf("Number = %d", 42) in C, we would use the following code.

mov rdi, message
mov rsi, 42
xor rax, rax
call printf

With the message string:

message: db 'Number = %d', 10, 0

Reference

Sample 64-bit nasm programs

Using the serial port with the Raspberry Pi model B

Sat, 17 Aug 2024 16:16:00 -0700

To ease the development of my Rapsberry Pi OS, I need to be able to connect a serial cable to the Raspberry Pi UART for debugging. This article gathers the steps that are necessary to connect to the Raspberry Pi UART with a USB cable.

Prerequisite

You will need the following items:

Raspberry Pi 1 Model B
Adafruit USB to TTL Serial Cable

Install the driver for the cable on Windows

The USB cable is not supported by default on Windows, it requires a driver.

You can download the driver from the manufacturer’s website Silicon Labs: CP210x USB to UART Bridge VCP Drivers. Once on the webpage, click on the Downloads tab and select the option CP210x Universal Windows Driver. At the time of writing the most recent option is version 11.3.0. Download and unzip the folder CP210x_Universal_Windows_Driver.zip on your computer.

Open the Windows device manager and find the device with a name like: “Silicon Labs CP210x USB to UART Bridge”. Right click on it and select Update driver. Windows will offer you the option to browse your computer for drivers, click on it and select the folder you previously unzipped.

Once the driver is installed, the computer will restart.

Activate the serial communication in Raspbian

By default the Raspberry Pi will not communicate on the serial port, you need to activate it in Raspbian OS. Fortunately there is a configuration utility to activate serial communications.

$ sudo raspi-config

In the menu, select “3 Interface Options”.
In the menu, select “I6 Serial Port”.
A screen will ask if you want a login shell accessible over serial, select Yes.
Optionally a screen may ask you if you would like the serial port hardware to be enabled, select Yes.
A confirmation screen will apper and tell you what was configured.
Finally, Reboot the Raspberry Pi.

Connecting the serial cable

Connect the cable as shown on the image.

Note that if the Raspberry Pi is powered by the regular cable, DO NOT connect the red cable. However, if you want to power the Raspberry Pi with the serial cable, you could connect the red wire.

Opening a terminal on Windows with PuTTY

Now that the serial cable is connected to the Raspberry Pi, and it is powered, you can connect to the terminal on Windows using PuTTY.

To know which COM port the Raspberry Pi is connected to, open the Windows device manager, find the device with a name like: “Silicon Labs CP210x USB to UART Bridge”. At the end of the device’s name, the COM port will be shown. For example, Silicon Labs CP210x USB to UART Bridge (COM3).

On Windows, open PuTTY, and select a Serial connection type, on port COM3, with the speed 115200 bauds. Once the PuTTY window is open, press ENTER to start the communication.

Appendix: Connecting to the serial port with Windows 98

For a more vintage experience, I also tried to connect the Raspberry Pi to a Windows 98 laptop via the serial port (with a DB9 connector). I ordered an RS232 to TTL Converter Module from Amazon. It can convert the RS232 from the laptop’s serial port to a TTL serial communication that the Raspberry Pi understands.

With this adapter, all four cables (GND, TXD, RXD, VCC) need to be connected respectively to the same pins on the Raspberry Pi. Not connecting the VCC cable will result in defective communication, so do not forget to connect it.

Once all cables are connected, open PuTTY and start a connection to the COM1 port with 115200 bauds. Then, press Enter to start communications.

Start the Raspberry Pi by plugging its power cable. Hopefully you should see logs from Linux booting.

References

Helpful SSH commands

Sat, 30 Mar 2024 12:47:00 -0700

This page contains helpful SSH commands I use to connect to my home network when I am not home.

Proxy SOCKS5: Tunnel internet through SSH (like a VPN)

To access internet as if I were at home, I can use a proxy SOCKS5 SSH tunnel to a Linux gateway. This is secure, just like using a VPN.

ssh -D 1337 -q -C -N gateway.example.com

Regarding options:

-D 1337 open the SOCKS proxy on local port 1337
-C compress the data in the tunnel
-q quiet mode, no output in the terminal
-N do not execute remote commands

The web browser (e.g., Firefox) needs to be configured to route traffic through the proxy. Only the internet traffic will go through the proxy.

Source: Create a SOCKS proxy on a Linux server with SSH to bypass content filters

Forward a port from another computer via a proxy VM

To access a service hosted on a VM on my home network (e.g., Microsoft RDP), I can forward the port for the service to my local computer via a SSH proxy using the Linux gateway.

                  (SSH proxy)
Me (on my laptop) ----------> Linux gateway VM ----> Windows VM
(office network)              (home network)         (home network)

For example, for forwarding RDP via a gateway:

ssh -L 3389:windows.example.com:3389 gateway.example.com

Source: Remote Desktop over SSH SOCKS proxy to bypass firewall

How to compile HPL LINPACK on Ubuntu 22.04

Sat, 27 Aug 2022 07:00:00 -0700

The High-Performance Linpack benchmark is a tool to evaluate the floating point performance of a computer. It is used to benchmark the fastest supercomputers in the world (see the Top500 list). The way it works is that it solves a giant system of linear equations Ax=b by parallelizing computations on many compute nodes.

In this article, we will look at how to compile and run the High-Performance Linpack benchmark on Ubuntu 22.04.

1) How to build HPL on Ubuntu 22.04?

Install dependencies

On Ubuntu 22.04 the following packages are needed to be able to compile and run HPL.

$ sudo apt install build-essential hwloc libhwloc-dev libevent-dev gfortran

Compile OpenBLAS

OpenBLAS is a standard BLAS (Basic Linear Algebra Subprograms) library that is used to perform linear algebra operations. There are many different implementations of the BLAS specification. I chose OpenBLAS because it runs on all platforms (Intel and AMD), and gives good results without needing expessive fine tuning at compile time. To get the absolute best performances, the BLAS library should be specific to the machine on which it runs. Other options for a linear algebra library include:

Intel oneMKL on a system with an Intel CPU
AMD BLIS on a system with an AMD CPUs

The following commands will compile and install OpenBLAS in your user directory under ~/opt/OpenBLAS/.

$ git clone https://github.com/xianyi/OpenBLAS.git
$ cd OpenBLAS
$ git checkout v0.3.21
$ make
$ make PREFIX=$HOME/opt/OpenBLAS install

Compile OpenMPI

The MPI library is used to communicate between processes, either on the same machine, or across machines of the same compute cluster. The following commands will compile and install OpenMPI in your user directory under ~/opt/OpenMPI/.

$ wget https://download.open-mpi.org/release/open-mpi/v4.1/openmpi-4.1.4.tar.gz
$ tar xf openmpi-4.1.4.tar.gz
$ cd openmpi-4.1.4
$ CFLAGS="-Ofast -march=native" ./configure --prefix=$HOME/opt/OpenMPI
$ make -j 16
$ make install

To make OpenMPI available to the system, some environment variables need to be updated. Note that, these commands work only for the current bash session and need to be reentered if the session is restarted.

export MPI_HOME=$HOME/opt/OpenMPI
export PATH=$PATH:$MPI_HOME/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MPI_HOME/lib

Compile HPL

Note that for some reason, the benchmark needs to be compiled in the user directory ~/hpl, hence the command mv hpl-2.3 ~/hpl.

$ wget https://netlib.org/benchmark/hpl/hpl-2.3.tar.gz
$ gunzip hpl-2.3.tar.gz
$ tar xvf hpl-2.3.tar
$ rm hpl-2.3.tar
$ mv hpl-2.3 ~/hpl

We need to configure HPL for the current system. We copy a generic Makefile and customize it for our system.

$ cd hpl/setup
$ sh make_generic
$ cp Make.UNKNOWN ../Make.linux
$ cd ../
# Specify the paths to libraries
$ nano Make.linux

In Makefile Make.linux, the following lines need to be modified to tell the compiler where our libraries are located.

The name of the current architecture (same as in the filename: Make.linux)

ARCH         = linux

The location of the OpenMPI library:

MPdir        = $(HOME)/opt/OpenMPI
MPinc        = -I$(MPdir)/include
MPlib        = $(MPdir)/lib/libmpi.so

The location of the OpenBLAS library:

LAdir        = $(HOME)/opt/OpenBLAS
LAinc        =
LAlib        = $(LAdir)/lib/libopenblas.a

Now to compile, we just need to run the following command:

$ make arch=linux

The resulting binary will be located at: bin/linux/xhpl.

How to run HPL?

Configuration

First, we need to move to the directory containing the executable of the benchmark.

# Move the executable directory
$ cd bin/linux
# Edit the configuration file
$ nano HPL.dat

Second, we need to edit the HPL.dat configuration file, which contains some parameters of the benchmark. These parameters influence the result of the benchmark and finding the values that give the best results can take a lot of time. Some important parameters to consider are:

N that is the size of the problem to solve, usually it should take a large part of the RAM on the compute node
NB that is the block size of the algorithm, usually it goes from 96 to 256 in steps of 8,
P and Q defines the number of MPI processes to solve the linear system, usually P x Q is equal to the number of nodes in the cluster.

The following webpage gives explanation about all parameters in the HPL.dat file: HPL Official Tuning Doc. It is a very useful resource to understand what parameters change, and what values may give the best results.

Here is an example HPL.dat file for a computer with 16GB of RAM and a single CPU:

HPLinpack benchmark input file
Innovative Computing Laboratory, University of Tennessee
HPL.out      output file name (if any) 
          device out (6=stdout,7=stderr,file)
          # of problems sizes (N)
      Ns
          # of NBs
        NBs
          PMAP process mapping (0=Row-,1=Column-major)
          # of process grids (P x Q)
          Ps
          Qs
0         threshold
          # of panel fact
          PFACTs (0=left, 1=Crout, 2=Right)
          # of recursive stopping criterium
          NBMINs (>= 1)
          # of panels in recursion
          NDIVs
          # of recursive panel fact.
          RFACTs (0=left, 1=Crout, 2=Right)
          # of broadcast
          BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM)
          # of lookahead depth
          DEPTHs (>=0)
          SWAP (0=bin-exch,1=long,2=mix)
         swapping threshold
          L1 in (0=transposed,1=no-transposed) form
          U  in (0=transposed,1=no-transposed) form
          Equilibration (0=no,1=yes)
          memory alignment in double (> 0)
##### This line (no. 32) is ignored (it serves as a separator). ######
                             Number of additional problem sizes for PTRANS
10000 30000                values of N
                             number of additional blocking sizes for PTRANS
9 8 13 13 20 16 32 64        values of NB

Finally, something worth checking out is this website: How do I tune my HPL.dat file?. It generates a tuned version of the HPL.dat file based on the characteristics of your compute cluster: number of nodes, cores per node, memory per node, and block size.

Running on a single CPU system

On a single CPU system, in the HPL.dat file, set the number of problems to: P=1 and Q=1.

# No need to use mpirun or specify the number of cores, OpenBLAS is multi-threaded by default
$ ./xhpl

Note that if the system has a single CPU socket but the CPU includes multiple NUMA nodes (like an AMD Ryzen Threadripper 2990WX), to get the best results, the computation should be distributed on the NUMA nodes (see the next section).

Running on a dual CPU system

On a dual CPU system, in the HPL.dat file, set the number of problems to the number of NUMA nodes: P=1 and Q=2.

# Sets the thread affinity for OpenMP, threads will not be moved between cores
$ export OMP_PROC_BIND=TRUE
# Tells OpenMP to place threads on physical cores, not hyper-threaded cores
$ export OMP_PLACES=cores
# Here replace 12 by the number of physical cores per CPU (without counting hyper-threaded cores)
$ export OMP_NUM_THREADS=12
# Here replace 2 by the number of CPUs in the machine
$ mpirun -n 2 --map-by l3cache --mca btl self,vader xhpl

Interpreting results

After running the benchmark, the output should look like the following. Towards the middle of the output, in the table, the number 2.2444e+02 means that the result of the benchmark is 224.4 Gflops. For reference, this was run in a VM on a laptop equipped with an Intel Core i7-10875H.

===============================================================================
HPLinpack 2.3  --  High-Performance Linpack benchmark  --   December 2, 2018
Written by A. Petitet and R. Clint Whaley,  Innovative Computing Laboratory, UTK
Modified by Piotr Luszczek, Innovative Computing Laboratory, UTK
Modified by Julien Langou, University of Colorado Denver
================================================================================

An explanation of the input/output parameters follows:
T/V    : Wall time / encoded variant.
N      : The order of the coefficient matrix A.
NB     : The partitioning blocking factor.
P      : The number of process rows.
Q      : The number of process columns.
Time   : Time in seconds to solve the linear system.
Gflops : Rate of execution for solving the linear system.

The following parameter values will be used:

N      :   29232 
NB     :     232 
PMAP   : Row-major process mapping
P      :       1 
Q      :       1 
PFACT  :   Right 
NBMIN  :       4 
NDIV   :       2 
RFACT  :   Crout 
BCAST  :  1ringM 
DEPTH  :       1 
SWAP   : Mix (threshold = 64)
L1     : transposed form
U      : transposed form
EQUIL  : yes
ALIGN  : 8 double precision words

--------------------------------------------------------------------------------

- The matrix A is randomly generated for each test.
- The following scaled residual check will be computed:
      ||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- The relative machine precision (eps) is taken to be               1.110223e-16
- Computational tests pass if scaled residuals are less than                16.0

================================================================================
T/V                N    NB     P     Q               Time                 Gflops
--------------------------------------------------------------------------------
WR11C2R4       29232   232     1     1              74.20             2.2444e+02
HPL_pdgesv() start time Sat Aug 27 11:36:48 2022

HPL_pdgesv() end time   Sat Aug 27 11:38:02 2022

--------------------------------------------------------------------------------
||Ax-b||_oo/(eps*(||A||_oo*||x||_oo+||b||_oo)*N)=   2.06977736e-03 ...... PASSED
================================================================================

Finished      1 tests with the following results:
              1 tests completed and passed residual checks,
              0 tests completed and failed residual checks,
              0 tests skipped because of illegal input values.
--------------------------------------------------------------------------------

End of Tests.
================================================================================

References

Automatic Differentiable Procedural Modeling

Thu, 28 Apr 2022 00:00:00 -0700

Mathieu Gaillard, Vojtech Krs, Giorgio Gori, Radomir Mech, Bedrich Benes
Computer Graphics Forum - Eurographics 2022 Full Paper

Teaser

Abstract

Procedural modeling allows for an automatic generation of large amounts of similar assets, but there is limited control over the generated output. We address this problem by introducing Automatic Differentiable Procedural Modeling (ADPM). The forward procedural model generates a final editable model. The user modifies the output interactively, and the modifications are transferred back to the procedural model as its parameters by solving an inverse procedural modeling problem. We present an auto-differentiable representation of the procedural model that significantly accelerates optimization. In ADPM the procedural model is always available, all changes are non-destructive, and the user can interactively model the 3D object while keeping the procedural representation. ADPM provides the user with precise control over the resulting model comparable to non-procedural interactive modeling. ADPM is node-based, and it generates hierarchical 3D scene geometry converted to a differentiable computational graph. Our formulation focuses on the differentiability of high-level primitives and bounding volumes of components of the procedural model rather than the detailed mesh geometry. Although this high-level formulation limits the expressiveness of user edits, it allows for efficient derivative computation and enables interactivity. We designed a new optimizer to solve for inverse procedural modeling. It can detect that an edit is under-determined and has degrees of freedom. Leveraging cheap derivative evaluation, it can explore the region of optimality of edits and suggest various configurations, all of which achieve the requested edit differently. We show our system’s efficiency on several examples, and we validate it by a user study.

Results

Eurographics 2022 Fast-forward

Eurographics 2022 Talk

Bibtex

@article{Gaillard22EG,  
  journal = {Computer Graphics Forum},  
  title = {Automatic Differentiable Procedural Modeling},  
  author = {Gaillard, Mathieu and Krs, Vojtech and Gori, Giorgio and Mech, Radomír and Benes, Bedrich},  
  year = {2022},  
  publisher = {The Eurographics Association and John Wiley & Sons Ltd.},  
  issn = {1467-8659},  
  doi = {10.1111/cgf.14475}  
}

My concerts with Purdue Bands & Orchestras

Wed, 20 Apr 2022 08:00:00 -0700

While doing my PhD at Purdue University, I played trumpet with the Purdue Concert Band, Symphony Orchestra, and Philharmonic Orchestra, here are some videos of our concerts. Because of COVID, some of these concerts were closed to the public, but livestreamed on YouTube.

List of concerts:

Philharmonic Orchestra Fall 2022: second concert
Symphony Orchestra Fall 2022: second concert
Philharmonic Orchestra Fall 2022: first concert
Symphony Orchestra Fall 2022: first concert
Philharmonic Orchestra Spring 2022: second concert
Philharmonic Orchestra Spring 2022: first concert
Philharmonic Orchestra Fall 2021: second concert
Philharmonic Orchestra Fall 2021: first concert
Concert Band Spring 2021: second concert
Concert Band Spring 2021: first concert
Concert Band Fall 2020: second concert
Concert Band Fall 2020: first concert

Pictures of me playing with the Purdue Philharmonic Orchestra

Playing trumpet (March 4, 2022)

After the concert (October 3, 2021)

Philharmonic Orchestra Fall 2022: second concert

Overture to Rusland and Ludmilla, Mikhail Glinka.
Dances of Galanta, Zoltan Kodaly.
Prelude to Die Meistersinger von Nürnberg, Richard Wagner.

Symphony Orchestra Fall 2022: second concert

Declaration Overture, Claude T. Smith. Sheep May Safely Graze, J. S. Bach. Eljen a Magyar, Johann Strauss, Jr.
Berceuse and Finale from The Firebird Suite, Igor Stravinsky. A Christmas Festival, Leroy Anderson.
Played as an extra Trumpet 3 player, with two rehearsals before concert.

Philharmonic Orchestra Fall 2022: first concert

Toccata and Fugue in D minor, Bach.
Romanian Folk Dances, Béla Bartok.
The Three Cornered Hat, Manuel de Falla.

Symphony Orchestra Fall 2022: first concert

Procession of the Nobles, English Folk Songs, Brandenburg Sinfonia,
Highlights from West Side Story, E.T., The Old Schenectady.
Played as an extra Trumpet 3 player, with two rehearsals before concert.

Philharmonic Orchestra Spring 2022: second concert

The Moldau, Bedrich Smetana. October, Eric Whiteacre. Capriccio Espagnol, Nikolai Rimsky-Korsakov.

Philharmonic Orchestra Spring 2022: first concert

Scheherazade, Nikolai Rimsky-Korsakov.

Philharmonic Orchestra Fall 2021: second concert

Elegy for Orchestra, John Berners. Symphony No. 8, Antonin Dvorak.

Philharmonic Orchestra Fall 2021: first concert

Emperor Waltz, Johann Strauss II.

Death and Transfiguration, Richard Strauss.

Concert Band Spring 2021: second concert

Concert Band Spring 2021: first concert

Concert Band Fall 2020: second concert

Concert Band Fall 2020: first concert

Compute pi with an HPC cluster using Monte Carlo

Fri, 18 Mar 2022 08:00:00 -0700

In a previous article, we installed an HPC cluster on virtual machines. Let’s write a program that uses the HPC cluster to compute an approximate value of pi. We will see how to distribute a task on multiple compute nodes, and how to efficiently aggregate all results on the master node using MPI in C++.

Computing pi using Monte Carlo integration

To compute pi, we use a Monte Carlo integration technique. The idea is to repeatedly sample the domain of the function we want to integrate and count how many samples land in the function versus outside the function. For pi, we want to integrate a quarter of the unit disk, whose area is pi/4. Although there are more elaborate Monte Carlo techniques, we stick with the basic just to get started.

Here is the algorithm:

We sample N points randomly on the unit square a. We count the number M of random samples that land into the unit disk
Pi is approximately equal to 4M/N

Following is a diagram to get a better understanding of how random samples are used to compute pi.

In this figure, the square represents the unit square, the circle represents a quarter of the unit disk. Dots represent all the random samples among which blue dots are in the unit disk, and orange dots are outside the unit disk but inside the unit square. In this case, with 22 samples in the disk and 28 total samples, the approximation of pi is pi=4*22/28=3.1428...

Parallelizing computations

The simplest approach to parallelize the computation of pi with Monte Carlo is to split the random generation and the counting of samples on multiple processes. Each node of our cluster will draw n random points in the unit square, and check whether they are in the unit disk or not. Note that when parallelizing this algorithm, there is a fine detail that we absolutely need to pay attention to. The random number generators need to be initialized with a different seed on each node. Otherwise, all nodes will generate the exact same sequence of random samples. Not only it defeats the purpose of parallelizing, but also the computation will be biased, and we will most likely not get the correct approximation of pi.

// Initialize the random number generator, make sure the seed is different on each node
// By using the the formula s = a*x + b*y, we minimize the probability of collisions for the seeds
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
std::mt19937_64 random_generator(449251 * seed + 26722 * world_rank);

Now here is an interesting question: how are the individual samples added up together to form the final result? We will see that there are multiple approaches, some of which are more efficient than others.

Naïve implementation with MPI_Send and MPI_Recv

The most straightforward method is to send all partial results to the master node when computations are done.

// Compute values locally on each processor
auto [circle_points, square_points] = estimate_pi(random_generator, n);
// Naive reduce implementation, implemented using MPI_Send and MPI_Recv
int64_t global_circle_points = circle_points;
int64_t global_square_points = square_points;
if (world_rank == 0)
{
    // The master node receives from all other nodes
    for (int source = 1; source < world_size; source++)
    {
        MPI_Status status;
        MPI_Recv(&circle_points, 1, MPI_LONG_LONG, source, 0, MPI_COMM_WORLD, &status);
        MPI_Recv(&square_points, 1, MPI_LONG_LONG, source, 0, MPI_COMM_WORLD, &status);
        global_circle_points += circle_points;
        global_square_points += square_points;
    }
}
else
{
    // All nodes send their result to the master
    MPI_Send(&circle_points, 1, MPI_LONG_LONG, 0, 0, MPI_COMM_WORLD);
    MPI_Send(&square_points, 1, MPI_LONG_LONG, 0, 0, MPI_COMM_WORLD);
}

Here is a diagram showing what is happening with 4 processes:

Efficient implementation with MPI_Reduce

A more interesting method is to use a tree structured communication to aggregate the results to the master node. In fact, one drawback of the naïve approach is that almost all the compute nodes are idle while the master node is aggregating results. By using a tree structured communication pattern, we maximize the utilization of compute node, and therefore we decrease the total number of communication stages from o(n) to o(log n). This can be a huge savings.

// Compute values locally on each processor
auto [circle_points, square_points] = estimate_pi(random_generator, n);
// Efficient reduce implementation, implemented using MPI_Reduce
MPI_Reduce(&circle_points, &global_circle_points, 1, MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&square_points, &global_square_points, 1, MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);

In this implementation we use the MPI_Reduce function that is part of the MPI standard. The purpose of this function to make reductions efficiently by using a tree reduction. Furthermore, on supercomputers, it is possible to have a custom implementation of this routine that is more efficient because it works with the specific network architecture in mind.

Here is a diagram showing what is happening with 4 processes:

Performance comparison

I ran my code on one of the university supercomputers: Halstead. It has nodes with 20 cores and InfiniBand interconnection. I ran the naïve as well as the efficient implementations on 1 and 5 nodes to see if there are any benefits in using the efficient implementation. Following is a table with timings:

	Naïve on 20 cores	Efficient on 20 cores	Naïve on 100 cores	Efficient on 100 cores
Run 1	0.0848 s	0.0350 s	0.2444 s	0.1872 s
Run 2	0.0622 s	0.0481 s	0.2305 s	0.1908 s
Run 3	0.0624 s	0.0653 s	0.2507 s	0.1773 s
Run 4	0.0624 s	0.0426 s	0.2313 s	0.1127 s
Run 5	0.0644 s	0.0424 s	0.2507 s	0.0737 s
Mean	0.0672 s	0.0467 s	0.2415 s	0.1484 s
Std	0.0099 s	0.0114 s	0.0100 s	0.0524 s

As we can see, in both cases the efficient implementation is significantly faster than the naïve implementation.

Computing an approximation of pi

Now that we have seen an interesting fact about programming with MPI, one question remains. Is our implementation any good for approximating the value of pi? Well unfortunately, the answer is no. When running the code with 1 billion samples, the result is consistently precise up to 3 digits, and it takes a couple of seconds on my laptop. I even ran it on one of the university supercomputers with 10 billion samples, I got the following result in about 5.5 seconds on 100 cores: pi = 3.14161. Although this code is terrible for estimating PI, it is nevertheless a good example on how to use MPI for distributing a simple computation on many nodes and aggregating the results. Although this approach for computing pi is a waste of time and resources, it is an interesting baseline, and we will see better approaches in the future.

Full code

#include <iostream>
#include <cstdint>
#include <tuple>
#include <random>
#include <chrono>

#include <mpi.h>

// Activate this define to test the naive implementation of the reduce operation
// #define NAIVE_REDUCE

template<class Generator>
std::tuple<int64_t, int64_t> estimate_pi(Generator& random_generator, int n)
{
    // Number of total random points
    const int64_t square_points = n;
    // Number of points in the circle
    int64_t circle_points = 0;

    std::uniform_real_distribution<double> distribution(0.0, 1.0);

    for (int i = 0; i < n; i++)
    {
        const double x = distribution(random_generator);
        const double y = distribution(random_generator);

        const double dist_sq = x*x + y*y;

        if (dist_sq <= 1.0)
        {
            circle_points++;
        }
    }
    
    return { circle_points, square_points };
}

int main(int argc, char** argv)
{
    MPI_Init(NULL, NULL);

    int world_size, world_rank;
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);
    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);

    // Total number of random samples 
    const int total_n = 1000000000;
    // Number of random samples per task
    const int n = total_n / world_size;

    // Initialize the random number generator, make sure the seed is different on each node
    // By using the the formula s = a*x + b*y, we minimize the probability of collisions for the seeds
    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
    std::mt19937_64 random_generator(449251 * seed + 26722 * world_rank);
    
    const double start_time = MPI_Wtime();

    // Compute values locally on each processor
    auto [circle_points, square_points] = estimate_pi(random_generator, n);

    // Reduce (sum) from all nodes to the root node
    int64_t global_circle_points, global_square_points;

#ifdef NAIVE_REDUCE
    // Naive reduce implementation, implemented using MPI_Send and MPI_Recv
    global_circle_points = circle_points;
    global_square_points = square_points;
    if (world_rank == 0)
    {
        // The master node receives from all other nodes
        for (int source = 1; source < world_size; source++)
        {
            MPI_Status status;
            MPI_Recv(&circle_points, 1, MPI_LONG_LONG, source, 0, MPI_COMM_WORLD, &status);
            MPI_Recv(&square_points, 1, MPI_LONG_LONG, source, 0, MPI_COMM_WORLD, &status);
            global_circle_points += circle_points;
            global_square_points += square_points;
        }
    }
    else
    {
        // All nodes send their result to the master
        MPI_Send(&circle_points, 1, MPI_LONG_LONG, 0, 0, MPI_COMM_WORLD);
        MPI_Send(&square_points, 1, MPI_LONG_LONG, 0, 0, MPI_COMM_WORLD);
    }
#else
    // Efficient reduce implementation, implemented using MPI_Reduce
    MPI_Reduce(&circle_points, &global_circle_points, 1, MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
    MPI_Reduce(&square_points, &global_square_points, 1, MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
#endif

    const double end_time = MPI_Wtime();

    // Only the master node computes the final result
    if (world_rank == 0)
    {
        const double pi = static_cast<double>(4 * global_circle_points) / global_square_points;
        std::cout << "pi = " << pi << std::endl;
        std::cout << "Calculated on " << world_size << " processors in "
                  << end_time - start_time << " s" << std::endl;
    }

    MPI_Finalize();

    return 0;
}

References

Chapter 4 of Parallel programming with MPI from Peter S. Pacheco
Estimating the value of Pi using Monte Carlo on GeeksForGeeks

Creating your own virtual HPC cluster

Tue, 15 Mar 2022 00:00:00 -0700

In this article, I am going to show you how to install an HPC cluster in virtual machines on your own computer. I focus on a minimalistic setup, with a couple of virtual machines connected to a shared storage. I will not show you how to install a cluster management system, nor will I show you how to setup and use a job scheduler. The main idea behind this article is to present the most straightforward and cost-effective way to get into supercomputer programming. For example, it can be a good platform to prototype and develop code that will eventually run on an HPC cluster. In fact, having your own virtual cluster allows you to test your programs without running an interactive session, and there is no overhead caused by the job scheduler: no need to submit a job to run the program, no need to wait for the program to even start.

Requirements

Regarding the hardware I am using, it is a laptop with 8 cores with Hyper-Threading and 32 GB of RAM. I am running one master node and 4 compute nodes, all of which are equipped with 2 cores and 4 GB of RAM. Although you can use a different software stack, throughout the article I will use the following software:

Windows 10 for the host OS
VMware Workstation Pro 16 for virtualization
Ubuntu Server 20.04 for the master and compute nodes
MPICH2 for message passing
NFS for shared storage

System diagram

Installation of the master node

Base installation

The first step is to install Ubuntu Server LTS on a virtual machine. Note that in this article, my username is mgaillard, you can of course change it to anything else. Following are the necessary packages for the master node:

# Install relevant packages for the master node
$ sudo apt install cmake git build-essential nfs-kernel-server nfs-common

Network configuration

Once the VM is installed, we need to configure its hostname and static IP address.

# Change the hostname to "master"
$ sudo nano /etc/hostname
# Assign a static IP address to the master node
$ sudo nano /etc/netplan/00-installer-config.yaml
# network:
#   ethernets:
#     ens33:
#       dhcp4: no
#       addresses:
#         - 192.168.154.3/24
#       gateway4: 192.168.154.2
#       nameservers:
#         addresses: [192.168.154.2]
#   version: 2

To ease communication with other nodes, we add their names to the hosts file. Change the /etc/hosts files with the command sudo nano /etc/hosts, and add the following lines at the beginning.

0.0.1 localhost

# MPI cluster setup
168.154.3 master
168.154.4 worker1
168.154.5 worker2
168.154.6 worker3
168.154.7 worker4

Install MPICH

MPICH is an implementation of the Message Passing Interface (MPI) standard. It is the library that is used by programs running on the HPC cluster to communicate between compute nodes. Note that another popular MPI library is OpenMPI. Following are the commands to download, compile, and install MPICH on Ubuntu.

# Download MPICH
$ wget https://www.mpich.org/static/downloads/4.0/mpich-4.0.tar.gz
$ tar xfz mpich-4.0.tar.gz
$ rm mpich-4.0.tar.gz
# Compile MPICH
$ cd mpich-4.0
$ ./configure --disable-fortran
$ make
$ sudo make install
# Check installation
$ mpiexec --version

Configuration of the NFS server

For the cluster to be able to execute the program in a distributed on multiple nodes simultaneously, it needs to be accessible from all nodes. For this, the simplest way is to setup a NFS share on the master node that is mounted on compute nodes.

# Create the shared directory on the master node
$ cd ~
$ mkdir cloud
# Add an entry to the /etc/exports file:
# /home/mgaillard/cloud *(rw,sync,no_root_squash,no_subtree_check)
$ echo "/home/mgaillard/cloud *(rw,sync,no_root_squash,no_subtree_check)" | sudo tee -a /etc/exports
$ sudo exportfs -ra
$ sudo mount -a
$ sudo service nfs-kernel-server restart

Installation of the worker nodes

Base installation

The first step is to install Ubuntu Server LTS on a virtual machine. To save time it is also possible to directly clone the master VM. In this case, remember to turn off the master node before booting the worker VM because they would both have the same IP address, which generates conflicts. Following are the necessary packages for the worker nodes:

# Install relevant packages for the worker nodes
$ sudo apt install cmake git build-essential nfs-common

Network configuration

Follow the same instructions as for the master node. Change the hostname and IP address based on the worker:

worker1: 192.168.154.4
worker2: 192.168.154.5
worker3: 192.168.154.6
worker4: 192.168.154.7

Change the /etc/hosts files with the command sudo nano /etc/hosts, and add the same lines as in the master node at the beginning of the file.

0.0.1 localhost

# MPI cluster setup
168.154.3 master
168.154.4 worker1
168.154.5 worker2
168.154.6 worker3
168.154.7 worker4

Install MPICH

To install MPICH on the worker nodes, follow the same instructions as for the master node.

Configuration of the NFS client

# Create the shared directory on the master node
$ cd ~
$ mkdir cloud
# On the workers, mount the shared directory located on the master node
$ sudo mount -t nfs master:/home/mgaillard/cloud ~/cloud
# Check mounted directories
$ df -h
# Make the mounts permanent, add the entry to the /etc/fstab file
$ cat /etc/fstab
# MPI cluster setup
master:/home/mgaillard/cloud home/mgaillard/cloud nfs

Cluster all nodes together

To make sure all nodes can seamlessly communicate together, we need to generate and copy SSH keys between them. On each node, run the following commands.

$ ssh-keygen -t ed25519
# Copy to SSH key to all other nodes (except the current node) 
$ ssh-copy-id master
$ ssh-copy-id worker1
$ ssh-copy-id worker2
$ ssh-copy-id worker3
$ ssh-copy-id worker4
# For passwordless SSH
$ eval "$(ssh-agent -s)"
$ ssh-add ~/.ssh/id_ed25519

Use the HPC cluster

In this section, we will write a simple Hello World program, compile it and run it on the HPC cluster. Create the file main.cpp in the shared directory and copy paste this program:

#include <mpi.h>
#include <stdio.h>

int main(int argc, char** argv)
{
    // Initialize the MPI environment
    MPI_Init(NULL, NULL);

    // Get the number of processes
    int world_size;
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);

    // Get the rank of the process
    int world_rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);

    // Get the name of the processor
    char processor_name[MPI_MAX_PROCESSOR_NAME];
    int name_len;
    MPI_Get_processor_name(processor_name, &name_len);

    // Print off a hello world message
    printf("Hello world from processor %s, rank %d out of %d processors\n",
           processor_name, world_rank, world_size);

    // Finalize the MPI environment.
    MPI_Finalize();

    return 0;
}

To ease compilation of C++ programs, I like to use CMake. Here is the CMakeLists.txt to compile the Hello World program:

cmake_minimum_required(VERSION 3.16.0)
project(MpiHelloWorld LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Activate OpenMP
find_package(OpenMP REQUIRED)

# Activate MPI
find_package(MPI REQUIRED)

add_executable(MpiHelloWorld)

target_sources(MpiHelloWorld
    PRIVATE
    main.cpp
)

target_link_libraries(MpiHelloWorld
    PRIVATE
    OpenMP::OpenMP_CXX
    MPI::MPI_CXX
)

Finally, to compile and run the Hello World program, use the following commands:

# Create the build folder
$ mkdir build && cd build
# Compile using CMake
$ cmake -DCMAKE_BUILD_TYPE=Release ..
$ cmake --build .
# Run the program on 4 nodes
$ mpirun -n 4 --hosts worker1,worker2,worker3,worker4 ./MpiHelloWorld

You should get a result similar to this:

Hello world from processor worker1, rank 0 out of 4 processors
Hello world from processor worker3, rank 2 out of 4 processors
Hello world from processor worker2, rank 1 out of 4 processors
Hello world from processor worker4, rank 3 out of 4 processors

References

The website MPI Tutorial has two relevant articles about creating a HPC cluster:

I found another older yet relevant article on this website:

Creating Your Own Cluster of VM’s to Run MPI Applications. Using Ubuntu Server 10.04 LTS.

Mathieu GAILLARD

Cross compilation from Ubuntu 24.04 to Windows 98

The program

How to build

It runs!

Conclusion

Using an SQL database as a job queue

PostgreSQL’s features for job queues

An example implementation

Installation

Database creation

Job producer

Job consumers

Validation

Launching the scripts

Conclusion

References

Calling printf in NASM assembly on Linux

Printing Hello World!

Explanations

Printing a number

Reference

Using the serial port with the Raspberry Pi model B

Prerequisite

Install the driver for the cable on Windows

Activate the serial communication in Raspbian

Connecting the serial cable

Opening a terminal on Windows with PuTTY

Appendix: Connecting to the serial port with Windows 98

References

Helpful SSH commands

Proxy SOCKS5: Tunnel internet through SSH (like a VPN)

Forward a port from another computer via a proxy VM

How to compile HPL LINPACK on Ubuntu 22.04

1) How to build HPL on Ubuntu 22.04?

Install dependencies

Compile OpenBLAS

Compile OpenMPI

Compile HPL

How to run HPL?

Configuration

Running on a single CPU system

Running on a dual CPU system

Interpreting results

References

Automatic Differentiable Procedural Modeling

Teaser

Abstract

Results

Eurographics 2022 Fast-forward

Eurographics 2022 Talk

Links

Bibtex

My concerts with Purdue Bands & Orchestras

Pictures of me playing with the Purdue Philharmonic Orchestra

Philharmonic Orchestra Fall 2022: second concert

Symphony Orchestra Fall 2022: second concert

Philharmonic Orchestra Fall 2022: first concert

Symphony Orchestra Fall 2022: first concert

Philharmonic Orchestra Spring 2022: second concert

Philharmonic Orchestra Spring 2022: first concert

Philharmonic Orchestra Fall 2021: second concert

Philharmonic Orchestra Fall 2021: first concert

Concert Band Spring 2021: second concert

Concert Band Spring 2021: first concert

Concert Band Fall 2020: second concert

Concert Band Fall 2020: first concert

Compute pi with an HPC cluster using Monte Carlo

Computing pi using Monte Carlo integration

Parallelizing computations

Naïve implementation with MPI_Send and MPI_Recv

Efficient implementation with MPI_Reduce

Performance comparison

Computing an approximation of pi

Full code

References

Creating your own virtual HPC cluster

Requirements

System diagram

Installation of the master node