Week1

Week1

It is important to write portable code to have better compatibility.

Portable code – code that can easily run on all kinds of computer architectures.

Most modern compilers now would outperform assembly language (depends on the user case away).

There is a rise of the ARM processors. It is more energy efficient (the power consumption is low). It is mostly used mobile devices, but there is a trend towards using arm-based system in more than just mobile devices. For example, the new apple M chip earth on the arm perform.

It is important to try to have the software to be most optimized.

-       Ways to write or build code to have better performance(algorithm changes, operation sequencing, data type selection)

-       Do you want speed, low memory usage, low power consumption. What are you willing to trade off.

-       Picking which compiler will influence memory usage, speed, executable size, and power consumption.

-       Understanding the build process can have a big impact on how software’s would perform.

-       Profiling: identify the bottlenecks of the software and target it to make the software better perform.

A 6502 is a good starter to learn assembly. It is an easier platform to learn assembly. Getting the basics down before going into the big boy processors. Every processor has its own instruction set, but the base logic is share between them. Some Engineers that work in Motorola develop a less expensive processor(6502).

6502 layouts (256 bytes – 64k address space)(00-FF | 0-255):

-       Register: Accumulator (A) | X | Y

-       Program Counter (PC)

-       Status Register (PS)

-       Stack Pointer (SP) (Stacks build downwards in memory)

-       2 x execution unit

-       Instruction decoder / Dispatcher / Scheduler

-       Load / Store Unit

Flags: NV-BDIZC

3 letter code call monomic. They are instructions to tell the processor what to do. Every action you do can have an effect on the flags. Zero page is where we can do fast-access($0000-$00FF). $FE store a random number. Program starts at address $0600.

Simple code to color every pixel:

            LDA #$10       ; store the color at A

            LDY #$00       ; store 0 in Y

LOOP  STA $0200,Y

            STA $0300,Y

STA $0400,Y

STA $0500,Y

            INY

            BNE LOOP     ; go to LOOP is not zero (watching zero flag)

            RTS

            BRK

 

We can see how long it takes the code to execute. By looking every instruction in the documentation and their cycle and how many times it execute. Watch out for the brunch it could add 1 or 2 cycle on an instruction.

Pair-programming: 1 drivers, and 1 or more navigator (combine knowledge)

Comments

Post a Comment

Popular posts from this blog

Project Stage 3

Goal:   After checking if the options are valid. Have to create a global array of afmv_targets and unsigned int of afmv_cnt. This is for others to consume. -fafmv="default" will have a count of 0. -fafmv="default, abc" will have a count of 1. Try to use the target_clone in GCC. Make a afmv.h for the global var I have to make. Header file: #ifndef GCC_AFMV_H #define GCC_AFMV_H /* Storage global variable for AFMV*/ #define AFMV_MAX_ARRAY_SIZE 100 extern unsigned int afmv_cnt; extern char* afmv_targets[AFMV_MAX_ARRAY_SIZE]; #endif /* GCC_AFMV_H */ add include header in opts.cc update count and array if all options passes the chceck. unsigned int afmv_cnt = 0; char* afmv_targets[AFMV_MAX_ARRAY_SIZE]; and      if (!is_found) {           error_at(loc, "Unsupported option '%s'", feature);           is_valid = false;      } else {           afmv_targets[afmv_cnt++] = feat...
Read more

Week4

 Makefile   A Makefile is a text file used with the GNU Make utility to automate the compilation process in GCC. It specifies the instructions for building an executable or library from your source code files. This is like building a LEGO set. makefile takes all the different pieces and put them together. One of the benefits is when rebuilding makefile only update the part that need to. so it just switch out a small part of the LEGO set, no need to start from stretch. Reduce time of building a new version speed up developing time.  On the project I will be
Read more

Week 3

Compiler Compiler is like a translator. Human type things they better understand (more human friendly), than it will change it to what the machine understands. There is few steps on translating code. (pre-processing | compiling | assembling | linking). Pre-prcessing is to prepare the human typed code for the next step. It can be removing your comments. compiling this is the step that the code is being translated to assembly language so it's one step closer to what machine can read. Assembling is taking those assembly language and making them in to machine code which computer can read and run. Linking, is other code or set of instructions and combine it with your code for the program to work. Knowing how compilers improve your code lets you trust them to make your easy-to-read code run faster. This lets you focus on more important stuff, like picking the best ways to solve problems and how to store your data. The compiler we focus on is GCC. GCC options: -o flag: (the strictest of...
Read more