http://jendralhxr.blogspot.com/2017/10/we-all-of-us.html

I think the third part of the saga is about memories and reminiscence. We hear more voice echoes and occasional dissonant piano chords. Around the 3:00 mark, we hear the memoriiiiies. Grey did not elect to fill in the piano chords, this is not just any other pop song.

 

Compared to the older version (below), 2023's is definitely darker. It is no longer about anger, anguish, and helplessness. Death (as in void/emptiness) perhaps?



flashing latest jetpack (5.1.2 atm) for nvidia jetson xavier agx

My work pc is running the latest ubuntu jammy (22.04LTS) and NVidia has yet to release the promised Jetpack 6 and sdkmanager [supposedly] featuring ubuntu jammy for both the host and target board.

The latest jetpack currently available (5.1.2) features ubuntu focal (20.04LTS) target. They provided some docker images for the host, but the actual run-ability is questionable and we need some more workaround. Some ppl had it easy, most others struggled (here, here, and others).

Inside the docker container (host), we need to modify /etc/issue, /etc/lsb-release, /etc/os-release and /etc/apt/source.list to "pretend" as ubuntu jammy if your actual host is not actually one.

Here is my flashing/installation notes:

# on the host
- make sure you have working **docker**
- download the sdkmanager docker image for ubuntu 20.04 (focal), for some reason I could not flash my jetson xavier using due to some missing jetpack packages when using the 22.04 (jammy) docker image
$ sudo update-binfmts --enable
$ docker load -i sdkmanager*tar.gz
$ docker run -it --rm --name=sdkmanager --rm=true --net=host --ipc host --privileged --cap-add SYS_ADMIN --volume="/dev/bus/usb:/dev/bus/usb" --entrypoint bash sdkmanager
# inside the container
- edit /etc/os-release /etc/lsb-release /etc/issue to trick the sdkmanager that we are running ubuntu focal
- edit your /etc/apt/source.list to reflect ubuntu focal.
$ apt-get -f install
$ sudo apt install libxshmfence libnss3 libatk-bridge2.0-0 libdrm2 libgtk-3-0 libgbm-dev
Check available jetpack packages on pick the one suitable for your device.
$ sdkmanager --query
$ sdkmanager --cli install --logintype devzone --staylogin true --product Jetson --version 5.1.2 --targetos Linux --host --target JETSON_AGX_XAVIER_TARGETS --flash all
If you have the space to spare, you can save the docker container into a neatly packed image
$ docker commit sdkmanager nvidiaiwishyouwerekindertous
Ubuntu 20.04.6 LTS \n \l
view raw issue hosted with ❤ by GitHub
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=20.04
DISTRIB_CODENAME=focal
DISTRIB_DESCRIPTION="Ubuntu 20.04.6 LTS"
view raw lsb-release hosted with ❤ by GitHub
NAME="Ubuntu"
VERSION="20.04.6 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04.6 LTS"
VERSION_ID="20.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal
view raw os-release hosted with ❤ by GitHub
deb http://archive.ubuntu.com/ubuntu/ focal main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu/ focal-updates main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu/ focal-security main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu/ focal-backports main restricted universe multiverse
deb http://archive.canonical.com/ubuntu focal partner
view raw source.list hosted with ❤ by GitHub

multidimensional array: C/C++ vs Octave/Matlab

I use these two families of programming languages quite often. I did C/C++ first then Octave/Matlab later on. The two differ in how they handle multi-directional array, especially ones more than 3-nest deep.

We know that computer memory uses (virtual?) contiguous address of memory--so by any means they are 1-dimensional. But program (and in this regard, the programming language) needs to map them somehow to fit the continuous address arrangement abstraction.

On 3-dimensional array, with C it is:

unsigned int val[2][4][3];
for (i=0; i<2; i++){
    for (j=0; j<4; j++){
        for (k=0; k<3; k++){
            printf("%d %d %d %p\n", i, j, k, &(val[i][j][k]));
        }   
    }
}

*
0 0 0 00007ff73f2dd040
0 0 1 00007ff73f2dd044
0 0 2 00007ff73f2dd048
0 1 0 00007ff73f2dd04c
0 1 1 00007ff73f2dd050
0 1 2 00007ff73f2dd054
0 2 0 00007ff73f2dd058
0 2 1 00007ff73f2dd05c
0 2 2 00007ff73f2dd060
0 3 0 00007ff73f2dd064
0 3 1 00007ff73f2dd068
0 3 2 00007ff73f2dd06c
1 0 0 00007ff73f2dd070
1 0 1 00007ff73f2dd074
1 0 2 00007ff73f2dd078
1 1 0 00007ff73f2dd07c
1 1 1 00007ff73f2dd080
1 1 2 00007ff73f2dd084
1 2 0 00007ff73f2dd088
1 2 1 00007ff73f2dd08c
1 2 2 00007ff73f2dd090
1 3 0 00007ff73f2dd094
1 3 1 00007ff73f2dd098
1 3 2 00007ff73f2dd09c

*/

See the memory address changes LSB (least significant [4] bytes, lol) based on the variable's LSB (last-shown beacon, I am making up this abbreviation).

With Octave, the story is slightly different. The two pages from the official documentation:
- https://docs.octave.org/v4.0.3/Index-Expressions.html
- https://docs.octave.org/v5.1.0/Advanced-Indexing.html
don't help much as they only give example up to only 2-dimension.

>> val= reshape(1:2*4*3, 2,4,3);
>> val =
ans(:,:,1) =
   1   3   5   7
   2   4   6   8
ans(:,:,2) =
    9   11   13   15
   10   12   14   16
ans(:,:,3) =
   17   19   21   23
   18   20   22   24

>> val(:,1,:)
ans(:,:,1) =
   1
   2
ans(:,:,2) =
    9
   10
ans(:,:,3) =
   17
   18

>> val(1,:,:)
ans =
ans(:,:,1) =
   1   3   5   7
ans(:,:,2) =
    9   11   13   15
ans(:,:,3) =
   17   19   21   23
   

See.... the first index in the element actually iterates first, i.e. the LSB now becomes MSB. It is somewhat nice to have first index as row vector/identifier and second index for the column. But what about third index? Fourth?

Well, sometimes you just have embrace the quirk.