Tagged articles
Registers
37 articles · Page 1 of 1
This article explains what a CPU is, its three core components (ALU, control unit, registers), the fetch-decode-execute instruction cycle, and key performance metrics like clock speed, cores, threads, and cache hierarchy (L1/L2/L3).
ALUCPUControl Unit
0 likes · 9 min read

This article walks through the internal structure of a CPU—explaining the roles of registers, the arithmetic‑logic unit, the control unit, cache hierarchy, bus interface, clock, and pipeline—using diagrams, code snippets, and concrete examples to illustrate how each component works together.
ALUCPUCache
0 likes · 8 min read

The article explains the layered memory hierarchy of a computer—from ultra‑fast registers and multi‑level CPU caches to RAM, SSD/HDD storage, and dedicated VRAM—using everyday analogies and concrete examples, and shows why “out of memory” warnings appear.
CPU cacheRAMRegisters
0 likes · 6 min read

The article explains that the CPU, built from billions of transistors and embedded on a motherboard, acts as a computer's brain by fetching, decoding, and executing instructions, detailing its internal units, registers, program counter, flag register, branching, function calls, array addressing, and the five‑stage instruction pipeline.
CPUInstruction CycleRegisters
0 likes · 12 min read

This article explains the CPU as the computer’s brain, describing its transistor‑based construction, core functions of fetching, decoding and executing instructions, internal components like the control unit, ALU and registers, the program counter, branching, flag registers, function calls, memory addressing, and the five‑stage instruction execution pipeline.
CPUInstruction CycleRegisters
0 likes · 13 min read

The article explains that a CPU continuously repeats four stages—fetch, decode, execute, and write‑back—while highlighting the role of registers, the differences between CISC and RISC instruction sets, how function calls build and tear down stack frames, and why user‑mode coroutines are far lighter than kernel threads.
ARMCPUCoroutines
0 likes · 28 min read

This article introduces the basic structure of a general‑purpose CPU used in AI chips, describing the arithmetic‑logic unit (ALU), the different types of registers, and the controller, while also directing readers to extensive AI‑chip technical report collections for deeper study.
AI chipALUCPU
0 likes · 3 min read

This guide provides a thorough introduction to x86 assembly language, covering GNU syntax, CPU architecture, registers, instruction formats, data types, memory models, and practical examples with NASM and GNU as, enabling readers to write efficient low‑level code and deepen their understanding of computer systems.
GNURegistersassembly
0 likes · 30 min read

This article explains why mastering assembly language is crucial for understanding how computers execute code, covering the nature of low‑level languages, CPU instruction encoding, registers, memory models such as heap and stack, and walks through a complete x86 example with detailed instruction analysis.
CPUHeapLow-Level Programming
0 likes · 14 min read

This article explains how a function call creates a stack frame that records the return address, registers, local variables, and parameters, detailing the roles of ESP and EBP registers and the step‑by‑step process of saving and restoring data on the call stack.
Function CallRegisterscall stack
0 likes · 5 min read

This article introduces x86 assembly language, explaining its historical origins, the role of CPU registers such as EAX and ESP, the heap and downward‑growing stack memory models, and demonstrates basic stack‑frame operations like push, call, mov, add, pop, and ret through a simple compiled example.
CPULow-Level ProgrammingMemory
0 likes · 13 min read

This article explains the fundamentals of CPUs, covering their definition, core functions, internal structure, registers, instruction cycles, assembly language, branching, and how they interact with memory and I/O devices to execute programs.
CPUInstruction CycleMemory
0 likes · 13 min read

This article explains the role of the CPU, its internal structure, key components like the control unit and ALU, registers, program counter, and how instructions are fetched, decoded, executed, and written back, using clear diagrams and examples.
CPUInstruction CycleRegisters
0 likes · 12 min read

This article explains the fundamental roles of the instruction pointer and registers in CPU operation, covering their definitions, update mechanisms, assembly-level manipulations such as jumps, calls, returns, conditional branches, loops, and interrupt handling with clear code examples.
CPU architectureLow-Level ProgrammingRegisters
0 likes · 7 min read

This article systematically analyzes a function call in an embedded system from four perspectives—assembly code, registers, stack layout, and map files—illustrating how the compiler generates the call, what values each register holds, how the stack is allocated, and how to trace execution using disassembly and memory views.
DebuggingRegistersassembly
0 likes · 7 min read

This article explains the fundamentals of a CPU, covering its definition, core functions, internal structure, registers, instruction cycle, assembly language basics, program counter, branching, flag registers, function calls, and how memory addressing enables array-like operations.
CPUInstruction CycleRegisters
0 likes · 13 min read

This article explains what a CPU is, how it processes instructions through fetch‑decode‑execute stages, its internal components such as the control unit, ALU and various registers, the role of memory and program counters, and introduces assembly language concepts and branching mechanisms.
CPUInstruction CycleRegisters
0 likes · 13 min read

This article demystifies the CPU by defining its role as the computer's brain, describing the fetch‑decode‑execute cycle, detailing its internal components such as the control unit, ALU and various registers, and explaining how instruction sets, assembly language, program counters, flags, function calls, and array addressing work together to run programs.
CPUInstruction CycleRegisters
0 likes · 12 min read

This article provides a comprehensive, step‑by‑step overview of CPU fundamentals, covering its definition, core functions, internal architecture, key registers, instruction execution stages, program counter behavior, conditional branching, flag registers, function calls, memory addressing, and the classic fetch‑decode‑execute pipeline.
CPUInstruction CycleRegisters
0 likes · 14 min read

This article provides an in‑depth technical overview of the NVMe (Non‑Volatile Memory Express) protocol over PCIe, covering its logical device interface, namespace concepts, queue mechanisms, register layouts, command formats, controller initialization, interrupt handling, and data protection features.
NVMePCIeRegisters
0 likes · 21 min read

This tutorial guides readers through installing a DOS environment, writing and analyzing a simple 8086 assembly program, understanding pseudo‑instructions, registers, instruction categories, execution flow, and data addressing, providing links and code examples for hands‑on learning.
8086Instruction SetLow-Level Programming
0 likes · 5 min read

This article explains how function calls are implemented using a stack‑based memory model, describing stack frames, the role of base and stack pointer registers, and the assembly instructions that create and dismantle these frames during program execution.
Function CallsRegistersassembly
0 likes · 7 min read

This article explains what program core dumps are, how to interpret core‑dump files, and provides detailed GDB debugging techniques—including register inspection, stack frame analysis, variable printing, memory dumping, and handling optimized code—to locate and resolve the root causes of crashes.
C++LinuxRegisters
0 likes · 16 min read


ITPUBAug 13, 2021 · Fundamentals
This article explains why a CPU with only a few small registers can still operate on massive in‑memory data structures by loading one element at a time using load/store instructions and how compilers strategically allocate registers to minimize memory traffic.
CPUCompilerLoad/Store
0 likes · 6 min read

The article explains how to analyze core‑dump files with GDB by examining the function call stack, key registers, and memory contents, classifying crash causes, using GDB commands to inspect variables and addresses, reconstructing corrupted stacks, handling optimized‑away data and vtable errors, and following a systematic debugging workflow.
DebuggingLinuxRegisters
0 likes · 17 min read

This article provides a comprehensive introduction to the fundamentals of x86 Linux, covering the historic Intel 8086 processor, segment descriptors, main memory organization, registers, bus architecture, CPU addressing modes, control mechanisms, and the basic instruction execution cycle.
CPULinuxMemory
0 likes · 15 min read

The article explains the purpose and structure of the memory hierarchy—from ultra‑fast registers and caches inside the CPU, through volatile main memory, to slower non‑volatile disks—showing how programs are loaded, executed, and how virtual memory and locality principles extend usable memory beyond physical limits.
CacheRegisterscomputer architecture
0 likes · 12 min read

This comprehensive guide explores the myriad x86/x64 CPU registers—including general, flag, instruction, segment, control, debug, descriptor, task, and model‑specific registers—explaining their roles, how they interact in memory addressing, multitasking, system calls, and debugging, while highlighting key differences between 32‑bit and 64‑bit modes.
CPURegisterscomputer architecture
0 likes · 21 min read

The article provides a thorough walkthrough of ARMv8 exception handling, describing the four exception levels (EL0‑EL3) and their dedicated stack and status registers, distinguishing synchronous and asynchronous faults, and detailing the vector table, entry routine, ESR‑based type decoding, handling steps such as do_mem_abort, and context restoration, illustrated with a Data Abort case.
ARMv8ELRESR
0 likes · 10 min read

This article explains the core components and operation of a CPU, covering the fetch‑decode‑execute cycle, instruction sets, registers, pipeline and superscalar designs, multi‑core and hyper‑threading concepts, and the hierarchy of caches from registers to L3, providing a comprehensive fundamentals overview.
CPUCacheMultithreading
0 likes · 14 min read

This article explains the purpose and usage of key ARMv8-A registers—including general‑purpose, stack‑pointer, SIMD/floating‑point, program status, link, and program counter registers—while detailing their encoding, access modes, and relevance to exception levels.
ARMARMv8Low-Level Programming
0 likes · 10 min read

This article provides a comprehensive overview of the ARMv8‑A architecture, explaining its RISC characteristics, execution states, instruction sets, register usage, and addressing modes, helping readers grasp the fundamentals needed to run operating systems like openEuler on ARM‑compatible servers.
ARMARMv8-AInstruction Set
0 likes · 9 min read

A comprehensive guide that walks you through the inner workings of a computer—from the CPU’s fetch‑decode‑execute cycle and register set, through memory hierarchy and binary arithmetic, to function calls, assembly language, and essential operating‑system concepts like APIs, multitasking and virtual memory.
CPUMemoryRegisters
0 likes · 68 min read


ITPUBAug 14, 2019 · Fundamentals
This article explains the core principles of CPU operation, covering instruction fetching, decoding, execution cycles, register types, pipeline and superscalar architectures, multi‑core and hyper‑threading designs, as well as the hierarchy of caches from registers to L3, providing a comprehensive overview of modern processor fundamentals.
CPUInstruction CycleMultithreading
0 likes · 13 min read

This article introduces the fundamentals of x86 assembly language, explaining why low‑level code is needed, the history of assembly, CPU registers, the heap and stack memory models, and walks through a complete example with detailed explanations of each assembly instruction.
CPUInstruction SetLow-Level Programming
0 likes · 14 min read

This article walks through a basic C "Hello World" program, shows its compiled assembly in Visual Studio, and explains each instruction and register to reveal the low‑level operations hidden behind a seemingly trivial example.
C++DebuggingLow-Level Programming
0 likes · 7 min read


21CTOAug 26, 2015 · Fundamentals
Registers outrun main memory because they sit closer to the CPU, employ high‑performance hardware designs, and involve far fewer access steps, a distinction illustrated with examples from iPhone 5s architecture and detailed step‑by‑step memory access processes.
CPU architectureRegistershardware design
0 likes · 6 min read
