DEV Community: Smit Gabani

SPO Project : Auto-vectorization with iFunc - Stage 1

Smit Gabani — Tue, 13 Dec 2022 21:35:14 +0000

"ifunc"

ifunc was introduced for developers to create programs that can use advance SIM, SVE, SVE2 i.e. create multiple implementation of a function and select amongst them at runtime using a resolver function.

The resolver function is used to determine between the different implemented functions based on the system's architecture. i.e. to determine the appropriate function during runtime.

Auto-vectorization:

... where a computer program is converted from a scalar implementation, which processes a single pair of operands at a time, to a vector implementation, which processes one operation on multiple pairs of operands at once.

Automatic vectorization have three major implementation of SIMD instructions for AArch64, Advanced SIMD, SVE and SVE2. Some modern gcc compiler have option to choose from one of these implementations at runtime using the function ifunc.

**Learn about ifunc and autovectorization to implement the project.

The purpose of the created tool is:

Given a function create and implement an ifunc resolver.Then automatically compile the function using auto-vectorization for multiple SIMD systems.Or the runtime compiler will choose one from them and generate a single output file.

Call the program in place of compiling. In between assembly and linking phase.

The language I will be using: Python

I am comfortable coding and understanding pyton code and I know python has many library that I can use. The reason I an not using C or C++ is that I am not sure I can complete the project if I face any troble while working with C++. But at last I decided to work with C

I plan that my code produces 3 builds successfully and automatically select a build that is appropriate with the hardware. Then execute the build. Should get the output. Different output can be used.

The program will accept 2 files one will be the main file and other will be the argument. For testing case function.c file which will contain a single function which will get vectorized.

The tool will only work on aarch64 system. So the testing will be done on the israel machine. Will focus on three SIMD implementations: ASIMD, SVE and SVE2.

Steps:
Get argument using sys i.e. function.c file.

Linker function
Functions for different modules
will figure out in the future.

Challenges:

Rename the functions and add those to ifunc c file and header file
Calling the linking stage multiple times during building for different modules.

SPO Project : Auto-vectorization with iFunc - Stage 3.2- after due

Smit Gabani — Tue, 13 Dec 2022 21:34:47 +0000

Testing:

Root dir:

Running

python3 tool.py --inputfile function.c

Missing tool.py running screenshot.

Some last min error occurred due to multiple file inputs I will blog on diff blog if it is past 11:59.

ls:

running the executable which has adjust chanels with

arguments test/input/bree.jpg 1.0 3.0 5.0 and test/output/breelaa.jpg
We can run this on israel machine which is an armv8

./main tests/input/bree.jpg 1.0 3.0 5.0 tests/output/breelaa.jpg

Emulating SVE2 system using qemu-aarch64:
Runnig with same arguments:

 qemu-aarch64 ./main tests/input/bree.jpg 1.0 3.0 5.0 tests/output/breel_qemu.jpg

The output are the same but the built implementation are different.
That does not mean that our function_sve2.o and function_asimd.o file are the same. I was working on comparing the .o files for diff arch using filecmp but no results. Still have written some code.

How to use the tool:

Run the tool which will accept the funciton.c file as an argument and produce the main exe file along with the functions it may use.

python3 tool.py --inputfile function.c

There are 2 test files (images) provided by the professor so we could use any of them.

./main tests/input/bree.jpg 1.0 3.0 5.0 tests/output/breelaa.jpg

The main executable will take the bree.jpg file and modify it based on the chosen function. So the first time we run the exe without qemu-aarch64 the asimd_adjust_chanels() function will be chosen using the iFunc resolver.
The output file should be stored in test/output dir. ## error

I forgot to share the screenshot of the modified tree after running the command.

The output image will be different from the original image.

References:

Help was provided by Naziur Khan.

Passing multiple arguments:
https://stackoverflow.com/questions/15753701/how-can-i-pass-a-list-as-a-command-line-argument-with-argparse

Using subprocess module: used when running external os system command and manuplate the command
subprocess.Popen() returns a exit code.
https://docs.python.org/3/library/subprocess.html

Extract a function writen in c from a file:
https://stackoverflow.com/questions/55078713/extract-function-code-from-c-sourcecode-file-with-python

Filecmp:
https://www.geeksforgeeks.org/python-filecmp-cmpfiles-method/

SPO 600 Project : Auto-vectorization with iFunc - Stage 3 - Final

Smit Gabani — Sat, 10 Dec 2022 01:27:36 +0000

I may create a new blog on this instead of editing this if the time passes 11:59.

My Github repo:
https://github.com/smitgabani/spo_project.git

Explain the code:

The python library used are:

subprocess - used when running external os system command and manuplate the command
shutil - for copy operation on a file
argparse - parsing argument 
sys - for exit codes
filecmp - for comparing output files (.o)

The file starts executing from main

First getting the arguments using argparser
arguments accepted are:
--inputfile: single or multiple file seprated by ','
--makeheaderfile: alternative to makeheaders.c file
--arch: different arch for compiling seprated by ','

Then getting all the .c files supplied in inputfile argument
Then loop through each file doing the following:
getting the function name.
Creating function files and prototypes for diff arch.
Process the argument files, Rewrite architecture files.
Write function_arch.c files
Compile the files
Check if the files are same if they are ...
Make ifunc header
Make ifunc code files.
Autovectorization.

I needed the bonus marks so I contected professor what functionality I could add and ....

Additional functions implemented:

aarch64 and x86_64 systems - could not be done but ....

Accept multiple function files You could pass multiple files but each file should contain only one funciton. seprate file name with (",") python3 tool.py --inputfile function.c,function2.c,function3.c

To test this I have created a function2.c file with the same function in function.c file but with different name i.e. function2

Notifying the user if autovectorization could not be applied (could have used exit code but have used sys.exit("what happened"))

Error handling has been done for the following.

If compilation of makeheaders could not be done.
If compilation for different arch could not be done. i.e. gcc -g -03 -c -march=armv8-a.. filename -o outputfilename could not be completed
If autovectorization could be completed and function_main is not generated.
Header file for the functions could not be created (stdout to output file)

Professor said it would be plus if I could check the output of all arch compilation and compare them if they are the same. If they are the same ...
done using filecmp

What the tool does:

In short:

Generates the following files
1.makeheaders_exe created after compiling makeheaders.c used to create .h file for function

Generated using makeheaders_exe to find the function names and prototype. Works for more than one function in a single file. Now I have used function.c file but if you pass --inputfile function.c,function2.c double the files will be generated.
function_asimd.c - function for Advanced SIMD build, function_sve.c - function for SVE build, function_sve2.c - function for SVE2 build
function_asimd.o - build for Advanced SIMD, function_sve.o - build for SVE, function_sve2.o - build for SVE2. produced after compiling respective .c files.
ifunc.c (generated resolver function for ASIMD, SVE,SVE2 build for the target functions)
ifunc.h (generated header of target functions for ASIMD, SVE,SVE2 variants) argument_main_exe file will be produced for each argument supplied.
function_main_exe (final compiled build file with auto vectorization capabilities)

Procedure and explaining the code:

When executed with ideal arguemnts the tool will parse the argument/s which would be a .c file which will have a single function. Then will use (compile) makeheaders.c file and then use the executable (makeheaders_exe) created to generated header file. i.e. function.c. Then from the header file created get the prototype(s) for the function in that file. I wanted to create a tool that could support multiple functions in a same file. Then create seprate files for all arch which will be the same but have different names. Some of it is explained above.

Testing:

Root dir:

Runing

python3 tool.py --inputfile function.c

Some last min error occured due to multiple file inputs I will blog on diff blog if it is past 11:59.

after compiling:

ls:

running the executable which has adjust chanels with arguments test/input/bree.jpg 1.0 3.0 5.0 and test/output/breelaa.jpg

We can run this on israel machine which is an armv8

./main tests/input/bree.jpg 1.0 3.0 5.0 tests/output/breelaa.jpg

Emulating SVE2 system using qemu-aarch64:
Runnig with same arguments:

 qemu-aarch64 ./main tests/input/bree.jpg 1.0 3.0 5.0 tests/output/breel_qemu.jpg

What I learned:

About different arch, how to modify code according to each one of them.

What I enjoyed:

I wrote some code that solved the limitation section and some additional functionality.

What I disliked:

Some part of ifunc I could not understand (why that code) and have a few unsolved doubts.

Will the tool be used by me in the future:
Maybee. I may write C code on diff arch. in the future if so I could use the

The code I picked of used up:
The code that utilizes or makes ifunc.c or ifunc.h

help and #uses in the code blocks

Consent: Yes

References:

Help was provided by Naziur Khan.

Passing multiple arguments:
https://stackoverflow.com/questions/15753701/how-can-i-pass-a-list-as-a-command-line-argument-with-argparse

Using subprocess module: used when running external os system command and manuplate the command
subprocess.Popen() returns a exit code.
https://docs.python.org/3/library/subprocess.html

Extract a function writen in c from a file:
https://stackoverflow.com/questions/55078713/extract-function-code-from-c-sourcecode-file-with-python

Filecmp:
https://www.geeksforgeeks.org/python-filecmp-cmpfiles-method/

SPO 600 Project : Auto-vectorization with iFunc - Stage 2

Smit Gabani — Fri, 09 Dec 2022 02:01:45 +0000

How to enable SVE and SVE2 on aarch64 systems:

gcc -g -O3 -c march=armv8-a+sve ...

gcc -g -O3 -c march=armv8-a+sve2 ...

How to enable SMID on aarch64 system:

gcc -g -O3 -march=armv8-a ...

I was having difficulty in deciding which language to choose. Initiall I went with pyton as I had thought it will be easy. Then as the complexity of the project increase I decide to go with C as I thought the it would be the choise as we get to use gcc the again I chose python after Chris recomended it.

My code can be found at:
https://github.com/smitgabani/spo600_project

Clone professors test code repo from;
https://github.com/ctyler/spo600-fall2022-project-test-code.git

I have used make header utility used by some of my friends.
https://github.com/bjconlan/makeheaders.git

Step 1
Start implementing 3 functions for different modules:

I started by going through some code that Chris provided and seperated the code.
Parse the string in order to get the function prototype and name. This took a lot of time.

Now I will use the header utility as mentioned above.
Next produce a code file called header.c and place the extracted prototype on top of that file.

Then get the name of the function in the test code and add a prefix to the name
for eg.
If the funtion's name is foo make three files foo_sve foo_sve2 foo_adSMID.

Step 2
Make a resolver function that will have the logic to choose what implementation will be run

Step 3

Testing on VS Code:

Error are due to the architecture.

To check the output we need to run the process on israel machine as the machine supports the architecutre.

Testing on Israel SPO600 server:

Emulating different stytems using different architecture.

So far the tool has errors.

SPO 600 Project : Auto-vectorization with iFunc - Stage 1

Smit Gabani — Fri, 09 Dec 2022 01:04:24 +0000

Objective:

The GCC compiler introduced the ‘ifunc’ extension to allow developers to create programs that can use advanced SIMD, SVE2, etc.
Our project is base on the use of ifunc and advanced SIMD, SVE2.

The goal for this project is to produce a proof-of-concept tool that will take code that meets specific conditions and automatically build it with ifunc capability to select between multiple, autovectorized versions of a function, to take advantage of the best SIMD implementation available on the CPU on which the code is running.

For a single instruction to be completed for multiple data unit different architecture have different SIMD implementations like advance SIMD, SVE and SVE2.

The tool designed by us will build 3 implementation for function.c file which wil have only one function.

The language I will be using: C

Overall Operation - Approach

I am some what confused no how to approach the problem.

Lets divide the working of the program into steps.

Get input
Parameters
Linker function
Functions for different modules
will figure out in the future.

The initial process will produce output similar to gcc compiler.

gcc -c func.c -o func.o

Challenges

Calling the linking stage multiple times during building for different modules.

SPO600 Lab 5 - Algorithm Selection Part 2: In depth

Smit Gabani — Fri, 04 Nov 2022 02:25:05 +0000

We want to measure the performance of each algorithm specifically and nothing else should be in the way in order to give a correct measurement of the time elapsed performing the algorithm.

In order to do that we need to make some modification to all the files.

I have the code here for vol0.c

// vol0.c - naive scaling algorithm
// Chris Tyler 2017.11.29-2021.11.16 - Licensed under GPLv3.
// For the Seneca College SPO600 Course

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include "vol.h"
#include <time.h>

int16_t scale_sample(int16_t sample, int volume) {

        return (int16_t) ((float) (volume/100.0) * (float) sample);
}

int main() {
        int             x;
        int             ttl=0;

// ---- Create in[] and out[] arrays
        int16_t*        in;
        int16_t*        out;
        in=(int16_t*) calloc(SAMPLES, sizeof(int16_t));
        out=(int16_t*) calloc(SAMPLES, sizeof(int16_t));

        clock_t start_t, end_t;
        start_t = clock();
// ---- Create dummy samples in in[]
        vol_createsample(in, SAMPLES);

// ---- This is the part we're interested in!
// ---- Scale the samples from in[], placing results in out[]
//
        for (x = 0; x < SAMPLES; x++) {
                out[x]=scale_sample(in[x], VOLUME);
        }
        end_t = clock();
        printf("Time elapsed: %f\n", ((double)start_t - end_t)/CLOCKS_PER_SEC);

// ---- This part sums the samples. (Why is this needed?)
        for (x = 0; x < SAMPLES; x++) {
                ttl=(ttl+out[x])%1000;
        }

// ---- Print the sum of the samples. (Why is this needed?)
        printf("Result: %d\n", ttl);

        return 0;
}

Declare start_t and end_t which are of type clock_t.

We wrap the scaleing part in start_t = clock(); and end_t = clock();.

And then print the time
printf("Time elapsed: %f\n", ((double)start_t - end_t)/CLOCKS_PER_SEC);.

DO THIS FOR ALL THE vol*.c FILES.

When you run the ./vol0 you will get such output.

Run the ./vol0 in a loop:

Observations:

AArch64 system:
vol0 vol1 vol2 vol4 vol5
1 4.980222 4.313869 10.567804 3.481179 4.04965
2 4.968114 4.323427 10.560218 3.456832 4.045124
3 4.959307 4.30239 10.59247 3.460554 4.045296
4 4.973315 4.325246 10.590718 3.469896 4.028074
5 4.961954 4.31275 10.585899 3.493608 4.039965
6 4.976137 4.320063 10.532851 3.438831 4.040304
7 4.959057 4.349743 10.642468 3.482111 4.055758
8 4.960718 4.317437 10.534451 3.469382 4.150955
9 4.95485 4.336698 10.548297 3.451517 4.085376
10 4.960642 4.329521 10.552774 3.455712 4.022335
11 4.952321 4.332141 10.550225 3.384459 4.041784
12 4.990002 4.334904 10.572559 3.423148 4.058293
13 4.942643 4.326342 10.545258 3.420771 4.096189
14 4.957297 4.317604 10.548684 3.391878 4.020974
15 4.967439 4.317819 10.558838 3.433111 4.062904
average 4.964267867 4.323996933 10.5655676 3.4475326 4.056198733
median 4.960718 4.323427 10.558838 3.455712 4.045296

SPO600 Lab 5 - Algorithm Selection Part 1: Introduction

Smit Gabani — Thu, 03 Nov 2022 08:23:36 +0000

Hi, I am Smit Gabani and in this blog I will introduce the Lab5.
For this lab we comparing the relative performance of various algorithms on the same computer on AArch64 and x86_64 systems.

Initial tasks:

Get example programs using

cp /public/spo600-volume-examples.tgz ~
tar -xvzf spo600-volume-examples.tgz

Change directory to where the Makefile stored. Using make to compile c-scripts.
Define SAMPLES in the header file vol.h and the scale of volume was set to 50% in this header file.
The memory used by these algorithm can be measured using free -m command in terminal.
Simple measure of time using time command.
Find a way to measure performance, using #include

What are inside the files:

vol.h
SAMPLES and VOLUME
In vol.h a large number of sample for the algorithms to process seems to be reasonable, because it will allow us to analyze the differences in terms of performance much easier.

vol0.c
In vol0.c, Audio samples are multiplied by the volume scaling factor, casting between signed 16-bit integers and floating-point values. This way takes up a lot of resources.

vol1.c
vol1.c utilizes a fixed-point calculation. This avoids the cost of repetitively casting between integer and floating point.

vol2.c
Unlike vol0.c and vol1.c, vol2.c pre-calculates all 65535 results, looking up answers for each input value afterward.

vol3.c
vol3.c returns an identical sample value, the purpose of this program seems to be a baseline to compare to the other scaling volume algorithm.

vol4.c
vol4.c uses the SIMD (Single Input, Multiple Data) instructions accessed through inline assembly. Which is only available on AArch64 architectures.

vol5.c
vol5.c like vol4.c also utilize SIMD instruction but with complier intrinsic built into the compiler. vol5.c is also specific to AArch64 due to usage of unique instructions of AArch64 architecture.

vol_createsample.c
vol_createsample.c contains the function vol_createsample(int16_t* sample, int32_t sample_count) that will be use to create dummy samples for the algorithms to run with.

My prediction:

Fastest: vol4, vol5
Average: vol2
Slowest: vol0, vol1

Running the programs with the time command (SAMPLES 16 VOLUME 50):

Running the programs with the time command (SAMPLES 500 VOLUME 50):

** Not all algorithms produce same result **
This is significant especially if the sample size increases.

Memory utilization:

Observation:
vol4 and vol5 are using much more memory that vol0, vol1, vol2, vol3.

SPO600 Lab 4 - Part 2: x86_64

Smit Gabani — Thu, 03 Nov 2022 05:02:10 +0000

Connecting to israel server.

ssh username@portugal.cdot.systems // replace username with your username.

Copy and unpack tarball, which for a windows user like me can be a new experience.

cp /public/filename ~
tar -xvzf filename

Modify the loop to run until 30 iterations (which took hours for me)

We need more steps to make the division work which makes the code longer and harder to make it work.

My x86_64 code:

.text
.globl  _start

min = 0                         
max = 30                       

_start:

        mov     $min,%r15           
        mov     $10, %r14
    mov     $10, %r13
        mov     %r15,%r13       
        mov     %r15,%r14      

        mov     $10,%r8
        movq    $len,%rdx                      


loop:

        mov     $0, %r11
            mov     %r9, %r12

            div     %r8    

        add     $'0',%12

        movb    %r14b,msg+6     


inner: 

        add     $'0', %11
        movb    %r13b,msg+7 



             movq    $msg,%rsi                      
            movq    $1,%rdi                        
        movq    $1,%rax                        
        syscall


        inc     %r15                
        cmp     $max,%r15           
        jne     loop                



        movq    $0,%rdi                        
        movq    $60,%rax                       
        syscall

.section .data

msg:    .ascii      "Loop: ##\n"
        len = . - msg

The code did not work for me on the portugal server.

SPO600 Lab 4 - Part 1: AArch64

Smit Gabani — Thu, 03 Nov 2022 04:50:55 +0000

In this lab we expriment with the x86_64 and aarch64 platforms with the loop code demonstrated by Chris Tyler.

The following tasks from lab 4 are completed and explained in this blog.

Connecting to israel server.
Copy and unpack tarball, which for a windows user like me can be a new experience.
Explore the files inside the spo600 folder and use the makefiles and make command to build the code.
Use objdump -d to inspect what was inside the binary file.
Modify the Hello World! In AArch64 and x82_64 to make it loop as demonstrated in the lab class.
Modify the loop to run until 30 iterations (which took hours for me)

Lets start with the lab.

Connecting to israel server.

ssh username@israel.cdot.systems // replace username with your username.

Copy and unpack tarball, which for a windows user like me can be a new experience.

cp /public/filename ~
tar -xvzf filename

Explore the files inside the spo600 folder and use the makefiles and make command to build the code. Use make clearfirst and then use make filename for a particular file or make for all files in the dir.
Use objdump -d to inspect what was inside the binary file. Move to the c dir and the use objdump -d to inspect the c code writen.
Modify the Hello World! In AArch64 and x82_64 to make it loop as demonstrated in the lab class.
Modify the loop to run until 30 iterations (which took hours for me)

The code of loop that would print the loop counter every iteration from 0 – 10 appending to a statically coded string “Loop”. This task alone took us about a half of the next class. And to even expand it, we had to write code to make the program print 2 digits instead of 1 from every iteration between 0 – 10. So the results would look like: Loop 00, Loop 01, Loop 02, Loop 03,…. Loop 30. And this also took about a half of the class.

My AArch64 final code:

.text
.globl _start
min = 0                          
max = 30 // should use 31

_start:

        mov     x15, 10 // for division
        mov     x19, min // value of the counter
        add     x18, x19, '0' //counter
        adr     x17, msg+6
        adr     x20, msg+7

loop:
        cmp x19, x15

        b.lt inside //start from smallest decimals

        udiv x12, x19, x15 // divide x19/x15 and store in x12 // udiv r0,r1,r2     // unsigned - divide r1 by r2, places quotient into r0 - remainder is not calculated (use msub)
        add x14, x12, '0'
        strb w14,[x17]

inside:

        msub x10,x15,x12,x19 //
        msub r0,r1,r2,r3  // load r0 with r3-(r1*r2) (useful for calculating remainders)
        add x10, x10, '0'
        strb w10,[x20]

        //Printing msg

        mov     x0, 1           
        adr     x1, msg         
        mov     x2, len         

        mov     x8, 64          
        svc     0               


        add x19, x19, 1 
        cmp x19, max
        b.ne loop


        //return

        mov     x0, 0           
        mov     x8, 93          
        svc     0               

.data
msg:    .ascii      "Loop: #\n"
len=    . - msg

here is my ./loop run on AArch64 on israel SPO Server.

While debugging, syntax errors are easy to correct but logical errors are much harder to correct in assembly. You have the debugger available to you and it will show you where your program catches a seg-fault and crashes but to understand why it’s causing the seg-fault may not be clear, making it extremely difficult to fix.

SPO600 Lab 3 - Math and Strings - Guessing Numbers.

Smit Gabani — Wed, 28 Sep 2022 04:54:22 +0000

In my previous blog I started developing a number guessing game. The game. The game has some milestones:

Accept number from the player.
Compare two numbers.
Generate a random number and store it.
Compare the number accepted by the user with the random number.

In my previous blog we have completed the first 2 parts. Now lets start with the next part.

Generate a random number and store it.

So the program generates and stores the random number (answer) before starting to get the input number ('start:' part) since it needs to keep getting the input until the user inputs the correct answer but the answer in one game (round) must not be changed.

; variables
define        answer    $16
;-------------------------------------------------------
lda $fe        ; generate random number
and #$99       ; mask out low two bits (=numbers 0-99)
sta answer    ; store the answer

start:        jsr PRINT

dcb $0d,$0d,"E","n","t","e","r",32,"a",32,"n","u","m","b","e","r"

After generating the random number we will compare the input by the player with the random number.

Here is the final code:

; A number guessing game

; ROM routine entry points
define        SCINIT        $ff81 ; initialize/clear screen
define        CHRIN        $ffcf ; input character from keyboard
define        CHROUT        $ffd2 ; output character to screen
define        SCREEN        $ffed ; get screen size
define        PLOT        $fff0 ; get/set cursor coordinates

; zeropage variables
define        PRINT_PTR    $10
define        PRINT_PTR_H    $11
define        value_h        $15
define        answer    $16

; absolute variables
define        GETNUM_1    $0080
define        GETNUM_2    $0081

; constants

; --------------------------------------------------------

        jsr SCINIT
        jsr CHRIN

        jsr PRINT

dcb "A",32,"n","u","m","b","e","r",32
dcb "g","u","e","s","s","i","n","g",32,"g","a","m","e",00

        lda $fe        ; generate random number
        and #$99       ; mask out low two bits (=numbers 0-99)
        sta answer     ; store the answer

start:        jsr PRINT

dcb $0d,$0d,"E","n","t","e","r",32,"a",32,"n","u","m","b","e","r"
dcb "(","0","-","9","9",")",":"
dcb 32,32,32,32,32,32,32,32,00

        lda #$00
        sta value_h

        jsr GETNUM

        sed        ; set decimal
        cmp answer ; compare user input to the answer
        cld        ; clear decimal flag (switches into binary math mode)

        bcc toolow    ; if input value is less than the answer, go to toolow
        beq identical    ; if input value is same as answer, go to identical

        ; otherwise (if input value is greater than the answer), go to toohigh
toohigh:    pha        ; push the accumulator
        jsr PRINT

dcb "T","o","o",32,"h","i","g","h",32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 00

        jsr start

toolow:        pha        ; push the accumulator
        jsr PRINT

dcb "T","o","o",32,"l","o","w",32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 00
        jsr start

identical:    pha        ; push the accumulator
        jsr PRINT

dcb "C","o","r","r","e","c","t",".",32
dcb "T","h","e",32,"a","n","s","w","e","r",32,"w","a","s",":"
dcb 32,32,32,32,32
dcb 00

        lda value_h
        beq low_digits
        lda #$31
        jsr CHROUT
        jmp draw_100s

low_digits:    lda answer
        and #$f0
        beq ones_digit

draw_100s:    lda answer
        lsr
        lsr
        lsr
        lsr
        ora #$30
        jsr CHROUT

ones_digit:    lda answer
        and #$0f
        ora #$30
        jsr CHROUT

        brk        ; if correct, break the program

; --------------------------------------------------------
; Print a message
; 
; Prints the message in memory immediately after the 
; JSR PRINT. The message must be null-terminated and
; 255 characters maximum in length.

PRINT:        pla    ; pull the accumulator
        clc    ; clear carry flag (C) - required before using ADC
        adc #$01    ; add with carry
        sta PRINT_PTR
        pla
        sta PRINT_PTR_H

        tya    ; transfer Y to A
        pha    ; push the accumulator

        ldy #$00
print_next:    lda (PRINT_PTR),y
        beq print_done

        jsr CHROUT
        iny
        jmp print_next

print_done:    tya
        clc
        adc PRINT_PTR
        sta PRINT_PTR

        lda PRINT_PTR_H
        adc #$00
        sta PRINT_PTR_H

        pla
        tay

        lda PRINT_PTR_H
        pha
        lda PRINT_PTR
        pha

        rts

; ---------------------------------------------------
; GETNUM - get a 2-digit decimal number
;
; Returns A containing 2-digit BCD value

GETNUM:        txa        ; transfer X to accumulator
        pha        ; push the accumulator
        tya        ; transfer Y to A
        pha

        ldx #$00    ; count of digits received
        stx GETNUM_1    ; store the X register
        stx GETNUM_2


getnum_cursor:    lda #$a0    ; black square
        jsr CHROUT
        lda #$83    ; left cursor
        jsr CHROUT

getnum_key:    jsr CHRIN
        cmp #$00
        beq getnum_key

        cmp #$08    ; BACKSPACE
        beq getnum_bs

        cmp #$0d    ; ENTER
        beq getnum_enter

        cmp #$30    ; "0"
        bmi getnum_key

        cmp #$3a    ; "9" + 1
        bmi getnum_digit

        jmp getnum_key

getnum_enter:    cpx #$00
        beq getnum_key

        lda #$20
        jsr CHROUT
        lda #$0d
        jsr CHROUT

        lda GETNUM_1

        cpx #$01
        beq getnum_done

        asl
        asl
        asl
        asl
        ora GETNUM_2

getnum_done:    sta GETNUM_1
        pla
        tay
        pla
        tax
        lda GETNUM_1

        rts

getnum_digit:    cpx #$02
        bpl getnum_key
        pha
        jsr CHROUT
        pla
        and #$0f
        sta GETNUM_1,x
        inx
        jmp getnum_cursor

getnum_bs:    cpx #$00
        beq getnum_key
        lda #$20
        jsr CHROUT
        lda #$83
        jsr CHROUT
        jsr CHROUT
        lda #$20
        jsr CHROUT
        lda #$83
        jsr CHROUT
        dex
        lda #$00
        sta GETNUM_1,x
        jmp getnum_cursor

I have used Chris Tyler's code from the repository of Wiki page.

SPO600 Lab 3 - Math and Strings - Guessing Numbers.

Smit Gabani — Tue, 27 Sep 2022 11:01:08 +0000

Assembly language is a type of low-level programming language that is intended to communicate with a computer's hardware more easily than high level languages. A high level language require compiler or interpreter to convert the language to binary code.

I will be using 6502 Emulator available at http://6502.cdot.systems/.

In lab 3 the task was to write either a game or a program that calculates or converts a value using 6502 Emulator.

I have decided to code a number guessing game where the player has to guess a random number. The goal is to guess the number with least amout of clues.

Two major tasks are:

Accept number from the player.
Compare two numbers.
Generate a random number and store it.
Compare the number accepted by the user with the random number.

; Comparing two numbers

; ROM routine entry points
define        SCINIT        $ff81 ; initialize/clear screen
define        CHRIN        $ffcf ; input character from keyboard
define        CHROUT        $ffd2 ; output character to screen
define        SCREEN        $ffed ; get screen size
define        PLOT        $fff0 ; get/set cursor coordinates

; zeropage variables
define        PRINT_PTR    $10
define        PRINT_PTR_H    $11
define        value        $14
define        value_h        $15

; absolute variables
define        GETNUM_1    $0080
define        GETNUM_2    $0081

; constants

; --------------------------------------------------------

        jsr SCINIT
        jsr CHRIN

        jsr PRINT

dcb "C","o","m","p","a","r","i","n","g",32,"t","w","o",32,
dcb "n","u","m","b","e","r","s",00

start:        jsr PRINT

dcb $0d,$0d,"E","n","t","e","r",32,"a",32,"n","u","m","b","e","r"
dcb "(","0","-","9","9",")",":"
dcb 32,32,32,32,32,32,32,32,00

        lda #$00
        sta value_h

        jsr GETNUM
        sta value

        jsr PRINT

dcb "E","n","t","e","r",32,"a","n","o","t","h","e","r"
dcb 32,"n","u","m","b","e","r",32,"(","0","-","9","9",")",":",32,00

        jsr GETNUM

        sed        ; set decimal
        cmp value
        cld        ; clear decimal flag (switches into binary math mode)

        bcc toohigh    ; if second value is less than the first value, go to toohigh
            beq identical    ; if second value is same as first one, 
        inc value_h    ; increment memory
toolow:           pha        ; push the accumulator
            jsr PRINT

dcb "N","u","m","b","e","r",32,"o","n","e",32,
dcb "i","s",32,"s","m","a","l","l","e","r",32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 00
            jsr start

identical:        pha        ; push the accumulator
            jsr PRINT

dcb "C","o","r","r","e","c","t",32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 00
            jsr start

toohigh:        pha        ; push the accumulator
            jsr PRINT

dcb "N","u","m","b","e","r",32,"o","n","e",32,
dcb "i","s",32,"g","r","e","a","t","e","r",32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 32,32,32,32,32,32,32
dcb 00
            jsr start

; --------------------------------------------------------
; Print a message
; 
; Prints the message in memory immediately after the 
; JSR PRINT. The message must be null-terminated and
; 255 characters maximum in length.

PRINT:        pla    ; pull the accumulator
        clc    ; clear carry flag (C) - required before using ADC
        adc #$01    ; add with carry
        ;sec ; set carry flag (C) - required before using SBC
        ;sbc #$01
        sta PRINT_PTR
        pla
        sta PRINT_PTR_H

        tya    ; transfer Y to A
        pha    ; push the accumulator

        ldy #$00
print_next:    lda (PRINT_PTR),y
        beq print_done

        jsr CHROUT
        iny
        jmp print_next

print_done:    tya
        clc
        adc PRINT_PTR
        sta PRINT_PTR

        lda PRINT_PTR_H
        adc #$00
        sta PRINT_PTR_H

        pla
        tay

        lda PRINT_PTR_H
        pha
        lda PRINT_PTR
        pha

        rts

; ---------------------------------------------------
; GETNUM - get a 2-digit decimal number
;
; Returns A containing 2-digit BCD value

GETNUM:        txa        ; transfer X to accumulator
        pha        ; push the accumulator
        tya        ; transfer Y to A
        pha

        ldx #$00    ; count of digits received
        stx GETNUM_1    ; store the X register
        stx GETNUM_2


getnum_cursor:    lda #$a0    ; black square
        jsr CHROUT
        lda #$83    ; left cursor
        jsr CHROUT

getnum_key:    jsr CHRIN
        cmp #$00
        beq getnum_key

        cmp #$08    ; BACKSPACE
        beq getnum_bs

        cmp #$0d    ; ENTER
        beq getnum_enter

        cmp #$30    ; "0"
        bmi getnum_key

        cmp #$3a    ; "9" + 1
        bmi getnum_digit

        jmp getnum_key

getnum_enter:    cpx #$00
        beq getnum_key

        lda #$20
        jsr CHROUT
        lda #$0d
        jsr CHROUT

        lda GETNUM_1

        cpx #$01
        beq getnum_done

        asl
        asl
        asl
        asl
        ora GETNUM_2

getnum_done:    sta GETNUM_1
        pla
        tay
        pla
        tax
        lda GETNUM_1

        rts

getnum_digit:    cpx #$02
        bpl getnum_key
        pha
        jsr CHROUT
        pla
        and #$0f
        sta GETNUM_1,x
        inx
        jmp getnum_cursor

getnum_bs:    cpx #$00
        beq getnum_key
        lda #$20
        jsr CHROUT
        lda #$83
        jsr CHROUT
        jsr CHROUT
        lda #$20
        jsr CHROUT
        lda #$83
        jsr CHROUT
        dex
        lda #$00
        sta GETNUM_1,x
        jmp getnum_cursor

Here is the result for the program.

So in this blog 2 out of 4 tasks have been completed.
I will write one more blog to complete the guessing game.

SPO600 Lab 2: Working with 6502 Emulator and bitmapped display.

Smit Gabani — Sat, 17 Sep 2022 23:01:23 +0000

In this post, I'm going to do some exercises using 6502 Emulator

I have already filled the bitmap display with yellow color. In this post, I'm going to change the code to get some different results.

The source code will will work on:

    lda #$00    ; set a pointer in memory location $40 to point to $0200
    sta $40     ; ... low byte ($00) goes in address $40
    lda #$02    
    sta $41     ; ... high byte ($02) goes into address $41

    lda #$07    ; colour number

    ldy #$00    ; set index to 0

loop:   sta ($40),y ; set pixel colour at the address (pointer)+Y

    iny     ; increment index
    bne loop    ; continue until done the page (256 pixels)

    inc $41     ; increment the page
    ldx $41     ; get the current page number
    cpx #$06    ; compare with 6
    bne loop    ; continue until done all pages

The result the code generates.

Assemble > Run > No errors > Yellow output.

Now lets modify the code to make the following changes.

Change the code to fill the display with light blue instead of yellow. (Tip: you can find the colour codes on the 6502 Emulator page).
Change the code to fill the display with a different colour on each page (each "page" will be one-quarter of the bitmapped display).

Making the changes.

Changing the color from yellow to light blue.

To chage the color from yellow to light blue we can change the line
lda #$07 to lda #$e
The color numbers are:

$0: Black
$1: White
$2: Red
$3: Cyan
$4: Purple
$5: Green
$6: Blue
$7: Yellow
$8: Orange
$9: Brown
$a: Light red
$b: Dark grey
$c: Grey
$d: Light green
$e: Light blue
$f: Light grey

The desired result is obtained.

I have checked the monitor checkbox to see how the light blue color is stored.

Change the code to fill the display with a different colour on each page.

Now, I'm going to change the code to fill the display with a different color on each page (each page: one-quarter of the bitmapped display).

This line is responsible for generating random color. (not exactly random).

inc $10 ; increment the color number

This is the final code:

        lda #$00    ; set a pointer at $40 to point to $0200
        sta $40
        lda #$02
        sta $41

        lda #$07    ; colour number
        sta $10 ; store colour number to memory location $10

        ldy #$00    ; set index to 0

loop:    sta ($40),y    ; set pixel at the address (pointer)+Y

        iny ; increment index
        bne loop    ; continue until done the page

        inc $41 ; increment the page

        inc $10 ; increment the color number
        lda $10 ; colour number

        ldx $41 ; get the current page number
        cpx #$06 ; compare with 6
        bne loop ; continue until done all pages

The final result:

This code will generate rendom color page using random color number ($fe)
You can also set the first color as a random color (lda $fe) by using pseudo-random number generator (PRNG) at $fe

  lda #$00    ; set a pointer at $40 to point to $0200
        sta $40
        lda #$02
        sta $41

        lda $fe ; random color
        sta $10 ; store colour number to memory location $10

        ldy #$00    ; set index to 0

loop:    sta ($40),y    ; set pixel at the address (pointer)+Y

        iny ; increment index
        bne loop    ; continue until done the page

        inc $41 ; increment the page

        inc $10 ; increment the color number
        lda $10 ; colour number

        ldx $41 ; get the current page number
        cpx #$06 ; compare with 6
        bne loop ; continue until done all pages

The more I work with the emulator the more I understand it.