Tuan Nguyen’s Post

I installed new memory into my computer. But I don't know why using GPU, system suddenly shutdown without any error. It's good experience to analysis failure cause and create simple checker. I've never think new memory make shutdown symptom in this case. https://lnkd.in/gYR2mZ2e

An example of running an AI chat in the terminal on a Kubernetes cluster. Because it's just using Phi-2 it works on CPU as well as GPU and it is actually able to write simple scripts. https://lnkd.in/eXurU6UW

#day77 of Learning cprogramming and embeddedsoftware 👉 Touched ch 5(pointers) of K & RC and updated my github today. 👉 Also, been revising and practising new problems in C programming Here's my github link:- https://lnkd.in/g52BE7Dt You can follow me- Prathamesh Barik on this fun and amazing journey of learning more about embeddedsoftware and cprogramminglanguage . See you soon. Summary of what I did in the last 77 days:- 1) I have completed reading "Programming in Embedded C and C++ by Michael barr". 2) Read the jsmn parser code https://lnkd.in/gPhCnJDA 3) Completed reading "The C Companion - ch 3 and 5" 4) Started reading and coding from "the C book by K & R". Completed ch-1,2, 3, and 4 5) completed a simple personal finance management project 6) Stanford linked list basics by nick parlante. 7) Stanford pointers by nick parlante. 8) Read the CLI infrastructure project code. 9) Completed the CLI infrastructure project by adding features and removing bugs. 10) Wrote blink_LED, GPIO code,LCD I2C and menu project for STM32F407. 11) Learning folder structure and controller startup+linker code. 12) Writing STM32F407 code for michael barr c and c++ #embeddedc #learningjourney #cprogramming #embeddedsoftware #embeddedsystems #rtos #firmware #microcontrollers #prathameshbarik

🚀 Stacks in ARMCortex-M(x) processors>> Our ex will be on Cortex-M4 processor - STM32f446 microcontroller (Nucleo board). ⚡ The processor uses a full descending stack. this means the stack pointer holds the address of the last stacked item in memory. ⭐ processor implements two stacks, the main stack (msp) and the process stack (psp). In Thread mode, the CONTROL register controls whether the processor uses the (msp) or the (psp). In Handler mode, the processor always uses the main stack. 📢 In Bit[1] of CONTROL register. • 0 = Main Stack Pointer (MSP). This is the reset value. • 1 = Process Stack Pointer (PSP). 📌 In our ex we take 1kbyte from stack from the end and divide it into two equal sections: 1️⃣ MSP section which is hold the address of (RAM_END) and it will take 512 byte, because in default initialization processor take the value of 1st address of flash region and put it into MSP. 2️⃣ PSP section which is hold the address of (RAM_END + 512) and it will take 512 byte too. then by default when the program is running the value in (SP) is the same value in (MSP) we need to link (SP) with (PSP) to do it, we must intialize (PSP) with any value once you do it you will can link it with (SP). **__asm volatile(".equ RAM_END, (0x20000000U + (128*1024)) "); // represents the preprocessor in assembly then we link (PSP) with (SP) by Putting 0x02 in CONTROL REG __asm volatile ("LDR R0, =#0x02"); __asm volatile ("MSR CONTROL, R0"); int func (multiply) >> proccessor is in thread mode and (PSP) Link with (SP), once func of generate interrupt executes the processor will be in handelr mode (MSP) will link with (SP). https://lnkd.in/dVUk3Kwh

Stability has released is third generation Image model First was stable Diffusion Second was SDXL Third is Stable Cascade https://lnkd.in/d2ec-4VA

- I am delightful that i have finished implementing the startup code file and linker script file from scratch of Stm32f407VG that based on ARM CortexM4. - Linker script file is used in linking stage to combine all object files with one object file and place layout of memory section addresses. -Startup code is used in reset mechanism to start the main application ; it has 5 main functions : 1.Intializing vector table. 2.Intializing stack pointer. 3.Intializing ".bss" segment. 4.Copy ".data" segment from Flash to RAM. 5.Calling main function. -Startup code use Linker script file to allocate section at memory for vector table and use addresses of sections. 📝 Source Code on my GitHub page : https://lnkd.in/dy5DN9mZ #embeddedsoftware #embeddedsystems #linkerscript #LinkerScripts #memory #microcontroller

How is #machinelearning beating best #video #compression algorithms H.264 and H.265. An independent developper did the #benchmark by using pretrained #diffusion #models. https://lnkd.in/e8T48uAX Imagine a compression algorithm that knows how to compress necause it can predict the rest od the movie. That's what Extreme Video Compression tries to do. At low bit rate the diffusion model performs astoundingly and remains extremely competitive in higher bit rates.

announcement! I have uploaded the driver for STM32F103C6T6 as "RCC" GitHub link: https://lnkd.in/d9-AXnVT Wait for more the drivers. #c #github #embeddedsystems #ARM #embedded_software #embedded #embeddedc

Last two weeks I've been optimizing our code base. Came up with this as a side product: https://lnkd.in/dU7FGhy2 The long story: When working with heterogeneous compute, most profilers don't do the job at finding the hotpots in your code. Actually, there tend to be "cold spots" unless you can keep all devices busy crunching numbers. This is a tricky equation to balance, if you have a typical CPU + GPU setup, the main job of the CPU will most likely be to keep the GPU busy + maintaining various "book keeping" tasks. However, the CPU and GPU need to be synchronized from time to time, and if the GPU is not kept busy, this can easily become a cold spot where the CPU code just blocks on a fence waiting for the GPU finish, instead of providing more data for it to munch upon. The problem with most profilers is that they do not measure time spent in I/O, mutex locks, and other sorts of inter-device communication. The simplest, and admittedly ugly strategy, is to use the debugger and randomly press Ctrl-C while running the code, inspect the stack trace, and continue. Doing this a couple of times can quickly show your "extreme spots". Traditionally this is known as the "poor mans debugger", or PMP for short. The repository linked above takes inspiration from this approach and automates it some scripts, such that it actually becomes a descent profiler, which I call p4. This has been extremely valuable to profile our code. By consistently applying p4 I have managed to refactor a CPU intensive algorithm with several fence related performance issues to the GPU and improved performance by more than 10x while doing so. Hope this comes to use for others as well, please let me know if it helps you, and please suggest improvements to the profiler if you have any!

Running llama2 model on CPU with the help of quantization technique: I have created simple LLM usecase(translation and RAG using FAISS vector db) which can run on cpu. Quantization reduce the cost of LLM while maintaining their performance. model used: llama-2-7b-chat.ggmlv3.q4_0.bin from HuggingFace. Feel free to reach out to me to learn about quantization and for any queries. Also, if you want to explore more on 1-bit LLM, you can query about "BitNet b1.58" Code can be found out here : https://lnkd.in/dc3YkMTd Thanks to Boktiar Ahmed Bappy for simplifying the concepts and to Krish Naik to make me understand the quantization technique.