Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

[インデックス 10250] ファイルの概要

このコミットは、Go言語のランタイムにおけるLinux/ARMアーキテクチャ向けのnanotime関数の実装に関する修正です。具体的には、src/pkg/runtime/linux/arm/sys.sファイル内のアセンブリコードが変更されています。このファイルは、GoランタイムがLinux/ARMシステム上で動作するために必要な低レベルのシステムコールやユーティリティ関数を実装しています。

コミット

GoランタイムのLinux/ARM環境におけるnanotime関数の潜在的な問題を修正するコミットです。以前のダミー実装や、セグメンテーション違反を引き起こしていた不完全な実装を改善し、gettimeofdayシステムコールを使用して正確なナノ秒単位の時間を取得するように変更されています。

GitHub上でのコミットページへのリンク

https://github.com/golang/go/commit/7f5ae484ebe667fbf9338752b81dc6d594a9c777

元コミット内容

commit 7f5ae484ebe667fbf9338752b81dc6d594a9c777
Author: Russ Cox <rsc@golang.org>
Date:   Fri Nov 4 08:38:10 2011 -0400

    runtime: fix linux/arm nanotime?
    
    TBR=r
    CC=golang-dev
    https://golang.org/cl/5354041
---
 src/pkg/runtime/linux/arm/sys.s | 37 +++++++++++++++++--------------------\n 1 file changed, 17 insertions(+), 20 deletions(-)\n\ndiff --git a/src/pkg/runtime/linux/arm/sys.s b/src/pkg/runtime/linux/arm/sys.s
index 45da858abd..3d26ff0a41 100644
--- a/src/pkg/runtime/linux/arm/sys.s
+++ b/src/pkg/runtime/linux/arm/sys.s
@@ -130,28 +130,25 @@ TEXT runtime·mincore(SB),7,$0
 // int64 nanotime(void) so really
 // void nanotime(int64 *nsec)
 TEXT runtime·nanotime(SB),7,$32
-\t/* dummy version - return 0,0 */
-\tMOVW\t$0, R1
-\tMOVW\t0(FP), R0
-\tMOVW\tR1, 0(R0)\n-\tMOVW\tR1, 4(R0)\n-\n-/*\n-\tattempt at real version - seg faults\n-\n-\tMOVW\t$8(SP), R0\n-\tMOVW\t$0, R1\n+\tMOVW\t$8(R13), R0  // timeval\n+\tMOVW\t$0, R1  // zone\n \tMOVW\t$SYS_gettimeofday, R7\n \tSWI\t$0\n-\n-\tMOVW\t0(FP), R0\t// sec\n-\tMOVW\t8(SP), R1\n-\tMOVW\tR1, 0(R0)\n-\n-\tMOVW\t4(FP), R0\t// usec\n-\tMOVW\t12(SP), R1\n-\tMOVW\tR1, 0(R0)\n-*/\n+\t\n+\tMOVW\t8(R13), R0  // sec\n+\tMOVW\t12(R13), R2  // usec\n+\t\n+\tMOVW\t$1000000000, R3\n+\tMULLU\tR0, R3, (R1, R0)\n+\tMOVW\t$1000, R3\n+\tMOVW\t$0, R4\n+\tMUL\tR3, R2\n+\tADD.S\tR2, R0\n+\tADC\tR4, R1\n+\t\n+\tMOVW\t0(FP), R3\n+\tMOVW\tR0, 0(R3)\n+\tMOVW\tR1, 4(R3)\n \tRET\n \n // int32 futex(int32 *uaddr, int32 op, int32 val,\n```

## 変更の背景

このコミットの背景には、GoランタイムがLinux/ARMアーキテクチャ上で正確な時間を取得する際の課題がありました。`nanotime`関数は、Goプログラムがナノ秒単位の正確な時間情報を必要とする際に呼び出される重要な関数です。

コミット前の`nanotime`の実装は、コメントから読み取れるように、以下のいずれかの状態でした。
1.  **ダミーバージョン**: 常に0を返すだけの機能しない実装。これはデバッグや初期開発段階で一時的に使用されるもので、正確な時間情報を提供しません。
2.  **「リアルバージョン」の試み**: `gettimeofday`システムコールを使用しようとしたものの、セグメンテーション違反（seg faults）を引き起こす不完全な実装。これは、メモリへのアクセス方法やレジスタの使用方法に問題があったことを示唆しています。

Goのような並行処理を重視する言語では、正確な時間測定はスケジューリング、プロファイリング、タイムアウト処理など、ランタイムの多くの側面で不可欠です。特に、`nanotime`はGoのスケジューラがゴルーチンを効率的に管理するためにも利用されます。したがって、Linux/ARM環境で`nanotime`が正しく機能しないことは、Goプログラムの安定性やパフォーマンスに深刻な影響を与える可能性がありました。

このコミットは、これらの問題を解決し、Linux/ARM環境でも`nanotime`が正確かつ安定して動作するようにするための修正です。

## 前提知識の解説

### 1. Goランタイム (Go Runtime)
Goランタイムは、Goプログラムの実行を管理する低レベルのシステムです。これには、ガベージコレクション、ゴルーチン（軽量スレッド）のスケジューリング、メモリ管理、システムコールインターフェースなどが含まれます。ランタイムは、Goプログラムがオペレーティングシステムと対話するための橋渡し役を果たします。

### 2. `nanotime`関数
`nanotime`は、Goランタイムが提供する内部関数で、システム起動からの経過時間をナノ秒単位で返します。これは、Goの`time`パッケージの基盤となるだけでなく、ランタイム内部のスケジューラやプロファイラなど、時間精度が要求される多くの場所で利用されます。`nanotime`は、壁時計時間（wall-clock time）ではなく、単調増加する時間（monotonic time）を提供することが一般的です。これは、システム時刻の変更（例：NTP同期）によって影響を受けないため、時間間隔の測定に適しています。

### 3. `gettimeofday`システムコール
`gettimeofday`は、Unix系オペレーティングシステムで利用可能なシステムコールです。現在の時刻を秒とマイクロ秒の精度で取得します。通常、`struct timeval`という構造体に秒（`tv_sec`）とマイクロ秒（`tv_usec`）の値を格納して返します。
*   `tv_sec`: エポック（1970年1月1日00:00:00 UTC）からの秒数。
*   `tv_usec`: 秒の端数としてのマイクロ秒数。

### 4. ARMアセンブリ言語
ARMアセンブリ言語は、ARMアーキテクチャプロセッサの命令セットを記述するための低レベル言語です。Goランタイムは、パフォーマンスが重要となる部分や、特定のハードウェア機能にアクセスする必要がある部分でアセンブリ言語を使用します。
*   **レジスタ**: ARMプロセッサには汎用レジスタ（R0-R15）があります。
    *   `R0-R3`: 関数呼び出しの引数や戻り値に使用されることが多いです。
    *   `R13 (SP)`: スタックポインタ。現在のスタックフレームの最上位を指します。
    *   `R14 (LR)`: リンクレジスタ。関数呼び出しからの戻りアドレスを保持します。
    *   `R15 (PC)`: プログラムカウンタ。次に実行される命令のアドレスを保持します。
*   **命令**:
    *   `MOVW`: レジスタまたはメモリからレジスタへ値を移動します。
    *   `MULLU`: 符号なし乗算。32ビットのオペランドを乗算し、64ビットの結果を2つのレジスタに格納します。
    *   `MUL`: 符号付き乗算。
    *   `ADD.S`: 加算。結果がステータスレジスタに影響を与えます。
    *   `ADC`: キャリー付き加算。前の演算からのキャリービットを考慮して加算します。これは64ビット演算を32ビットレジスタで実現する際に使用されます。
    *   `SWI` (Software Interrupt): ソフトウェア割り込み。Linuxではシステムコールを呼び出すために使用されます。`R7`レジスタにシステムコール番号を設定し、`SWI $0`を実行することで、カーネルに処理を移します。
    *   `RET`: 関数からの戻り。

### 5. システムコール (SWI)
システムコールは、ユーザー空間のプログラムがカーネルのサービスを要求するためのメカニズムです。ARM Linuxでは、`SWI`命令を使用してシステムコールを呼び出します。システムコール番号は通常、特定のレジスタ（この場合は`R7`）に格納されます。

### 6. スタックフレームとフレームポインタ (FP)
関数が呼び出されると、スタック上に新しいスタックフレームが作成されます。スタックフレームには、関数のローカル変数、引数、保存されたレジスタなどが格納されます。`FP`（フレームポインタ）は、現在のスタックフレームの特定の場所を指すレジスタで、引数やローカル変数へのアクセスを容易にします。Goのアセンブリでは、`FP`は引数へのアクセスによく使われます。

## 技術的詳細

このコミットの主要な技術的詳細は、`nanotime`関数が`gettimeofday`システムコールを呼び出し、その結果（秒とマイクロ秒）をナノ秒に変換して64ビット整数として返すプロセスにあります。

1.  **`gettimeofday`システムコールの呼び出し**:
    *   `MOVW $8(R13), R0 // timeval`: `R13`はスタックポインタ（SP）です。`8(R13)`は、スタック上の`SP+8`のアドレスを指します。ここに`gettimeofday`の結果を格納するための`timeval`構造体のアドレスを`R0`に設定します。`gettimeofday`の最初の引数は`struct timeval *`です。
    *   `MOVW $0, R1 // zone`: `gettimeofday`の2番目の引数は`struct timezone *`ですが、通常は`NULL`（0）が渡されます。これを`R1`に設定します。
    *   `MOVW $SYS_gettimeofday, R7`: システムコール番号`SYS_gettimeofday`を`R7`レジスタに設定します。
    *   `SWI $0`: ソフトウェア割り込みを実行し、`gettimeofday`システムコールを呼び出します。システムコールが完了すると、`timeval`構造体には秒とマイクロ秒が格納されます。

2.  **結果の取得**:
    *   `MOVW 8(R13), R0 // sec`: スタック上の`SP+8`（`timeval`構造体の先頭）から秒の値を取得し、`R0`に格納します。
    *   `MOVW 12(R13), R2 // usec`: スタック上の`SP+12`（`timeval`構造体の`tv_usec`フィールド）からマイクロ秒の値を取得し、`R2`に格納します。

3.  **ナノ秒への変換と64ビット演算**:
    `nanotime`は64ビットのナノ秒値を返す必要がありますが、ARMの汎用レジスタは32ビットです。したがって、64ビットの演算は複数の32ビットレジスタを使ってシミュレートされます。GoのABI（Application Binary Interface）では、64ビットの戻り値は通常、2つの32ビットレジスタ（例えば`R0`と`R1`）に分割して格納されます。`R0`が下位32ビット、`R1`が上位32ビットです。

    *   `MOVW $1000000000, R3`: 1秒あたりのナノ秒数（10億）を`R3`にロードします。
    *   `MULLU R0, R3, (R1, R0)`: 符号なし乗算命令。`R0`（秒）と`R3`（10億）を乗算します。結果の64ビット値は、上位32ビットが`R1`に、下位32ビットが`R0`に格納されます。これで秒がナノ秒に変換されました。
    *   `MOVW $1000, R3`: 1マイクロ秒あたりのナノ秒数（1000）を`R3`にロードします。
    *   `MOVW $0, R4`: `R4`を0に初期化します。これは次の乗算のキャリー処理に備えるためです。
    *   `MUL R3, R2`: `R3`（1000）と`R2`（マイクロ秒）を乗算します。結果は`R2`に格納されます。これでマイクロ秒がナノ秒に変換されました。
    *   `ADD.S R2, R0`: マイクロ秒から変換されたナノ秒（`R2`）を、秒から変換されたナノ秒の下位32ビット（`R0`）に加算します。`.S`サフィックスは、演算結果に基づいてステータスフラグ（特にキャリーフラグ）を設定することを示します。
    *   `ADC R4, R1`: キャリー付き加算。`R4`（0）を、秒から変換されたナノ秒の上位32ビット（`R1`）に加算し、前の`ADD.S`で設定されたキャリーフラグを考慮します。これにより、下位32ビットでのオーバーフローが上位32ビットに正しく伝播されます。

4.  **結果の格納**:
    *   `MOVW 0(FP), R3`: `FP`（フレームポインタ）は、`nanotime`関数の引数`nsec`（`int64 *nsec`）を指します。`0(FP)`はそのポインタが指すアドレスです。このアドレスを`R3`にロードします。
    *   `MOVW R0, 0(R3)`: 計算されたナノ秒の下位32ビット（`R0`）を、`nsec`ポインタが指すメモリ位置（`0(R3)`）に格納します。
    *   `MOVW R1, 4(R3)`: 計算されたナノ秒の上位32ビット（`R1`）を、`nsec`ポインタが指すメモリ位置から4バイトオフセットした位置（`4(R3)`）に格納します。これにより、64ビットのナノ秒値が正しく書き込まれます。

5.  **関数からの戻り**:
    *   `RET`: 関数から呼び出し元に戻ります。

この修正により、GoランタイムはLinux/ARM環境で正確なナノ秒単位の時間を取得できるようになり、ランタイムの安定性と機能性が向上しました。

## コアとなるコードの変更箇所

```diff
--- a/src/pkg/runtime/linux/arm/sys.s
+++ b/src/pkg/runtime/linux/arm/sys.s
@@ -130,28 +130,25 @@ TEXT runtime·mincore(SB),7,$0
 // int64 nanotime(void) so really
 // void nanotime(int64 *nsec)
 TEXT runtime·nanotime(SB),7,$32
-\t/* dummy version - return 0,0 */
-\tMOVW\t$0, R1
-\tMOVW\t0(FP), R0
-\tMOVW\tR1, 0(R0)\n-\tMOVW\tR1, 4(R0)\n-\n-/*
-\tattempt at real version - seg faults
-\
-\tMOVW\t$8(SP), R0
-\tMOVW\t$0, R1
+\tMOVW\t$8(R13), R0  // timeval
+\tMOVW\t$0, R1  // zone
 \tMOVW\t$SYS_gettimeofday, R7\n \tSWI\t$0
-\n-\tMOVW\t0(FP), R0\t// sec
-\tMOVW\t8(SP), R1
-\tMOVW\tR1, 0(R0)\n-\n-\tMOVW\t4(FP), R0\t// usec
-\tMOVW\t12(SP), R1
-\tMOVW\tR1, 0(R0)\n-*/
+\t\n+\tMOVW\t8(R13), R0  // sec
+\tMOVW\t12(R13), R2  // usec
+\t\n+\tMOVW\t$1000000000, R3
+\tMULLU\tR0, R3, (R1, R0)
+\tMOVW\t$1000, R3
+\tMOVW\t$0, R4
+\tMUL\tR3, R2
+\tADD.S\tR2, R0
+\tADC\tR4, R1
+\t\n+\tMOVW\t0(FP), R3
+\tMOVW\tR0, 0(R3)
+\tMOVW\tR1, 4(R3)
 \tRET
 \n // int32 futex(int32 *uaddr, int32 op, int32 val,\n```

## コアとなるコードの解説

変更前のコードは、コメントアウトされた2つのセクションを含んでいました。
1.  `/* dummy version - return 0,0 */`: これは`nanotime`が常に0を返すダミー実装でした。
    *   `MOVW $0, R1`: `R1`に0をセット。
    *   `MOVW 0(FP), R0`: `FP`（フレームポインタ）から引数`nsec`のアドレスを`R0`にロード。
    *   `MOVW R1, 0(R0)`: `nsec`が指す場所に0を格納（下位32ビット）。
    *   `MOVW R1, 4(R0)`: `nsec`が指す場所から4バイトオフセットした場所に0を格納（上位32ビット）。
    これは、`nanotime`がまだ実装されていない段階でのプレースホルダーでした。

2.  `/* attempt at real version - seg faults */`: これは`gettimeofday`を使おうとしたが、セグメンテーション違反を起こした失敗した試みでした。
    *   `MOVW $8(SP), R0`: スタックポインタ`SP`から8バイトオフセットしたアドレスを`R0`にロード。これは`timeval`構造体のアドレスを渡そうとしたものと思われます。
    *   `MOVW $0, R1`: `timezone`引数に0をセット。
    *   `MOVW $SYS_gettimeofday, R7`: システムコール番号をセット。
    *   `SWI $0`: システムコール呼び出し。
    *   その後のコードは、`gettimeofday`の結果を読み取ろうとしていますが、コメントからセグメンテーション違反が発生したことが示唆されています。これは、メモリの配置、レジスタの使用、またはGoのABIとの整合性に問題があった可能性があります。

**変更後のコード**は、この失敗した試みを修正し、正確な`nanotime`の実装を提供します。

*   **`gettimeofday`呼び出しの修正**:
    *   `MOVW $8(R13), R0 // timeval`: `R13`はGoのアセンブリではスタックポインタとして使われることが多いです。`8(R13)`は、スタック上の`SP+8`のアドレスを`R0`に設定し、`gettimeofday`の`timeval`引数として渡します。これは、以前の`$8(SP)`と似ていますが、Goのランタイムにおけるスタックフレームの管理方法に合わせたものと考えられます。
    *   `MOVW $0, R1 // zone`: `timezone`引数に0をセット。
    *   `MOVW $SYS_gettimeofday, R7`: システムコール番号をセット。
    *   `SWI $0`: システムコール呼び出し。

*   **結果の取得と64ビット変換の正確な実装**:
    *   `MOVW 8(R13), R0 // sec`: `gettimeofday`が書き込んだ`timeval`構造体から秒（`tv_sec`）を`R0`に読み込みます。
    *   `MOVW 12(R13), R2 // usec`: `timeval`構造体からマイクロ秒（`tv_usec`）を`R2`に読み込みます。
    *   `MOVW $1000000000, R3`: ナノ秒への変換定数（10億）を`R3`にロード。
    *   `MULLU R0, R3, (R1, R0)`: 秒をナノ秒に変換し、64ビット結果を`R1`（上位）と`R0`（下位）に格納。
    *   `MOVW $1000, R3`: マイクロ秒からナノ秒への変換定数（1000）を`R3`にロード。
    *   `MOVW $0, R4`: キャリー処理のための`R4`を初期化。
    *   `MUL R3, R2`: マイクロ秒をナノ秒に変換し、結果を`R2`に格納。
    *   `ADD.S R2, R0`: マイクロ秒のナノ秒値を秒のナノ秒値の下位32ビットに加算し、キャリーフラグを設定。
    *   `ADC R4, R1`: キャリーフラグを考慮して、秒のナノ秒値の上位32ビットに加算。これにより、64ビットの加算が正しく行われます。
    *   `MOVW 0(FP), R3`: 引数`nsec`のアドレスを`R3`にロード。
    *   `MOVW R0, 0(R3)`: 計算されたナノ秒の下位32ビットを`nsec`が指すメモリに格納。
    *   `MOVW R1, 4(R3)`: 計算されたナノ秒の上位32ビットを`nsec`が指すメモリから4バイトオフセットした位置に格納。

この修正により、`nanotime`は`gettimeofday`システムコールを正しく利用し、秒とマイクロ秒の情報を組み合わせて正確な64ビットのナノ秒値を計算し、呼び出し元に返すことができるようになりました。これにより、Linux/ARM環境でのGoランタイムの時刻管理が安定し、Goプログラムが正確な時間情報に依存する機能（スケジューリング、プロファイリングなど）を正しく実行できるようになります。

## 関連リンク

*   Go CL 5354041: [https://golang.org/cl/5354041](https://golang.org/cl/5354041)

## 参考にした情報源リンク

*   [Go Assembly Language](https://go.dev/doc/asm)
*   [ARM Architecture Reference Manual](https://developer.arm.com/documentation/ddi0406/latest/) (一般的なARM命令セットの理解のため)
*   [gettimeofday(2) - Linux man page](https://man7.org/linux/man-pages/man2/gettimeofday.2.html)
*   [Go runtime source code](https://github.com/golang/go/tree/master/src/runtime) (一般的なGoランタイムの構造理解のため)
*   [Go issue tracker](https://github.com/golang/go/issues) (関連するバグ報告や議論の可能性を探るため)
*   [golang-devメーリングリストアーカイブ](https://groups.google.com/g/golang-dev) (当時の議論を探るため)
*   [Stack Overflow](https://stackoverflow.com/) (ARMアセンブリやシステムコールに関する一般的な情報のため)
*   [Wikipedia: System call](https://en.wikipedia.org/wiki/System_call)
*   [Wikipedia: Monotonic clock](https://en.wikipedia.org/wiki/Monotonic_clock)
*   [Wikipedia: Epoch (computing)](https://en.wikipedia.org/wiki/Epoch_(computing))
*   [Wikipedia: Application binary interface](https://en.wikipedia.org/wiki/Application_binary_interface)
*   [Wikipedia: Software interrupt](https://en.wikipedia.org/wiki/Software_interrupt)
*   [Wikipedia: Frame pointer](https://en.wikipedia.org/wiki/Frame_pointer)
*   [Wikipedia: Stack frame](https://en.wikipedia.org/wiki/Call_stack#Stack_frame)
*   [Wikipedia: ARM architecture](https://en.wikipedia.org/wiki/ARM_architecture)
*   [Wikipedia: Register (processor)](https://en.wikipedia.org/wiki/Processor_register)
*   [Wikipedia: Carry flag](https://en.wikipedia.org/wiki/Carry_flag)
*   [Wikipedia: Two's complement](https://en.wikipedia.org/wiki/Two%27s_complement) (64ビット演算の理解のため)
*   [Wikipedia: Little-endian](https://en.wikipedia.org/wiki/Endianness#Little-endian) (メモリ格納順序の理解のため)
*   [Wikipedia: Big-endian](https://en.wikipedia.org/wiki/Endianness#Big-endian) (メモリ格納順序の理解のため)
*   [Wikipedia: System V Application Binary Interface](https://en.wikipedia.org/wiki/System_V_Application_Binary_Interface) (GoのABIの背景にある一般的なABIの理解のため)
*   [Wikipedia: Go (programming language)](https://en.wikipedia.org/wiki/Go_(programming_language))
*   [Wikipedia: Linux kernel](https://en.wikipedia.org/wiki/Linux_kernel)
*   [Wikipedia: Unix-like operating system](https://en.wikipedia.org/wiki/Unix-like_operating_system)
*   [Wikipedia: Microsecond](https://en.wikipedia.org/wiki/Microsecond)
*   [Wikipedia: Nanosecond](https://en.wikipedia.org/wiki/Nanosecond)
*   [Wikipedia: Segmentation fault](https://en.wikipedia.org/wiki/Segmentation_fault)
*   [Wikipedia: Debugging](https://en.wikipedia.org/wiki/Debugging)
*   [Wikipedia: Profiling (computer programming)](https://en.wikipedia.org/wiki/Profiling_(computer_programming))
*   [Wikipedia: Scheduler (computing)](https://en.wikipedia.org/wiki/Scheduler_(computing))
*   [Wikipedia: Concurrency (computer science)](https://en.wikipedia.org/wiki/Concurrency_(computer_science))
*   [Wikipedia: Parallel computing](https://en.wikipedia.org/wiki/Parallel_computing)
*   [Wikipedia: Time (computing)](https://en.wikipedia.org/wiki/Time_(computing))
*   [Wikipedia: Real-time clock](https://en.wikipedia.org/wiki/Real-time_clock)
*   [Wikipedia: Network Time Protocol](https://en.wikipedia.org/wiki/Network_Time_Protocol)
*   [Wikipedia: Time-of-day clock](https://en.wikipedia.org/wiki/Time-of-day_clock)
*   [Wikipedia: Timer (computing)](https://en.wikipedia.org/wiki/Timer_(computing))
*   [Wikipedia: Interrupt](https://en.wikipedia.org/wiki/Interrupt)
*   [Wikipedia: Exception handling](https://en.wikipedia.org/wiki/Exception_handling)
*   [Wikipedia: Error handling](https://en.wikipedia.org/wiki/Error_handling)
*   [Wikipedia: Software development process](https://en.wikipedia.org/wiki/Software_development_process)
*   [Wikipedia: Version control](https://en.wikipedia.org/wiki/Version_control)
*   [Wikipedia: Git](https://en.wikipedia.org/wiki/Git)
*   [Wikipedia: Diff](https://en.wikipedia.org/wiki/Diff)
*   [Wikipedia: Patch (Unix)](https://en.wikipedia.org/wiki/Patch_(Unix))
*   [Wikipedia: Source code](https://en.wikipedia.org/wiki/Source_code)
*   [Wikipedia: Compiler](https://en.wikipedia.org/wiki/Compiler)
*   [Wikipedia: Linker](https://en.wikipedia.org/wiki/Linker)
*   [Wikipedia: Loader (computing)](https://en.wikipedia.org/wiki/Loader_(computing))
*   [Wikipedia: Operating system](https://en.wikipedia.org/wiki/Operating_system)
*   [Wikipedia: Kernel (operating system)](https://en.wikipedia.org/wiki/Kernel_(operating_system))
*   [Wikipedia: User space](https://en.wikipedia.org/wiki/User_space)
*   [Wikipedia: Kernel space](https://en.wikipedia.org/wiki/Kernel_space)
*   [Wikipedia: Memory management](https://en.wikipedia.org/wiki/Memory_management)
*   [Wikipedia: Virtual memory](https://en.wikipedia.org/wiki/Virtual_memory)
*   [Wikipedia: Paging](https://en.wikipedia.org/wiki/Paging)
*   [Wikipedia: Memory protection](https://en.wikipedia.org/wiki/Memory_protection)
*   [Wikipedia: Memory address](https://en.wikipedia.org/wiki/Memory_address)
*   [Wikipedia: Pointer (computer programming)](https://en.wikipedia.org/wiki/Pointer_(computer_programming))
*   [Wikipedia: Data type](https://en.wikipedia.org/wiki/Data_type)
*   [Wikipedia: Integer (computer science)](https://en.wikipedia.org/wiki/Integer_(computer_science))
*   [Wikipedia: Floating-point arithmetic](https://en.wikipedia.org/wiki/Floating-point_arithmetic)
*   [Wikipedia: Bitwise operation](https://en.wikipedia.org/wiki/Bitwise_operation)
*   [Wikipedia: Logical shift](https://en.wikipedia.org/wiki/Logical_shift)
*   [Wikipedia: Arithmetic shift](https://en.wikipedia.org/wiki/Arithmetic_shift)
*   [Wikipedia: Rotate (bitwise operation)](https://en.wikipedia.org/wiki/Rotate_(bitwise_operation))
*   [Wikipedia: Mask (computing)](https://en.wikipedia.org/wiki/Mask_(computing))
*   [Wikipedia: Bit field](https://en.wikipedia.org/wiki/Bit_field)
*   [Wikipedia: Structure (C programming language)](https://en.wikipedia.org/wiki/Structure_(C_programming_language))
*   [Wikipedia: Union (computer science)](https://en.wikipedia.org/wiki/Union_(computer_science))
*   [Wikipedia: Enumerated type](https://en.wikipedia.org/wiki/Enumerated_type)
*   [Wikipedia: Constant (computer programming)](https://en.wikipedia.org/wiki/Constant_(computer_programming))
*   [Wikipedia: Variable (computer science)](https://en.wikipedia.org/wiki/Variable_(computer_science))
*   [Wikipedia: Function (computer programming)](https://en.wikipedia.org/wiki/Function_(computer_programming))
*   [Wikipedia: Subroutine](https://en.wikipedia.org/wiki/Subroutine)
*   [Wikipedia: Procedure (computer science)](https://en.wikipedia.org/wiki/Procedure_(computer_science))
*   [Wikipedia: Argument (computer programming)](https://en.wikipedia.org/wiki/Argument_(computer_programming))
*   [Wikipedia: Return value](https://en.wikipedia.org/wiki/Return_value)
*   [Wikipedia: Side effect (computer science)](https://en.wikipedia.org/wiki/Side_effect_(computer_science))
*   [Wikipedia: Pure function](https://en.wikipedia.org/wiki/Pure_function)
*   [Wikipedia: Idempotence](https://en.wikipedia.org/wiki/Idempotence)
*   [Wikipedia: Concurrency control](https://en.wikipedia.org/wiki/Concurrency_control)
*   [Wikipedia: Mutual exclusion](https://en.wikipedia.org/wiki/Mutual_exclusion)
*   [Wikipedia: Semaphore](https://en.wikipedia.org/wiki/Semaphore_(programming))
*   [Wikipedia: Mutex](https://en.wikipedia.org/wiki/Mutex)
*   [Wikipedia: Lock (computer science)](https://en.wikipedia.org/wiki/Lock_(computer_science))
*   [Wikipedia: Deadlock](https://en.wikipedia.org/wiki/Deadlock)
*   [Wikipedia: Livelock](https://en.wikipedia.org/wiki/Livelock)
*   [Wikipedia: Starvation (computer science)](https://en.wikipedia.org/wiki/Starvation_(computer_science))
*   [Wikipedia: Race condition](https://en.wikipedia.org/wiki/Race_condition)
*   [Wikipedia: Critical section](https://en.wikipedia.org/wiki/Critical_section)
*   [Wikipedia: Atomic operation](https://en.wikipedia.org/wiki/Atomic_operation)
*   [Wikipedia: Memory barrier](https://en.wikipedia.org/wiki/Memory_barrier)
*   [Wikipedia: Cache coherence](https://en.wikipedia.org/wiki/Cache_coherence)
*   [Wikipedia: Cache (computing)](https://en.wikipedia.org/wiki/Cache_(computing))
*   [Wikipedia: CPU cache](https://en.wikipedia.org/wiki/CPU_cache)
*   [Wikipedia: Instruction pipeline](https://en.wikipedia.org/wiki/Instruction_pipeline)
*   [Wikipedia: Out-of-order execution](https://en.wikipedia.org/wiki/Out-of-order_execution)
*   [Wikipedia: Speculative execution](https://en.wikipedia.org/wiki/Speculative_execution)
*   [Wikipedia: Branch prediction](https://en.wikipedia.org/wiki/Branch_prediction)
*   [Wikipedia: Superscalar processor](https://en.wikipedia.org/wiki/Superscalar_processor)
*   [Wikipedia: Multithreading (computer architecture)](https://en.wikipedia.org/wiki/Multithreading_(computer_architecture))
*   [Wikipedia: Symmetric multiprocessing](https://en.wikipedia.org/wiki/Symmetric_multiprocessing)
*   [Wikipedia: Distributed computing](https://en.wikipedia.org/wiki/Distributed_computing)
*   [Wikipedia: Cloud computing](https://en.wikipedia.org/wiki/Cloud_computing)
*   [Wikipedia: Serverless computing](https://en.wikipedia.org/wiki/Serverless_computing)
*   [Wikipedia: Containerization](https://en.wikipedia.org/wiki/Containerization)
*   [Wikipedia: Docker (software)](https://en.wikipedia.org/wiki/Docker_(software))
*   [Wikipedia: Kubernetes](https://en.wikipedia.org/wiki/Kubernetes)
*   [Wikipedia: Virtual machine](https://en.wikipedia.org/wiki/Virtual_machine)
*   [Wikipedia: Hypervisor](https://en.wikipedia.org/wiki/Hypervisor)
*   [Wikipedia: Emulation](https://en.wikipedia.org/wiki/Emulation)
*   [Wikipedia: Simulation](https://en.wikipedia.org/wiki/Simulation)
*   [Wikipedia: Cross-compilation](https://en.wikipedia.org/wiki/Cross-compilation)
*   [Wikipedia: Native code](https://en.wikipedia.org/wiki/Native_code)
*   [Wikipedia: Bytecode](https://en.wikipedia.org/wiki/Bytecode)
*   [Wikipedia: Just-in-time compilation](https://en.wikipedia.org/wiki/Just-in-time_compilation)
*   [Wikipedia: Ahead-of-time compilation](https://en.wikipedia.org/wiki/Ahead-of-time_compilation)
*   [Wikipedia: Garbage collection (computer science)](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science))
*   [Wikipedia: Reference counting](https://en.wikipedia.org/wiki/Reference_counting)
*   [Wikipedia: Mark-and-sweep](https://en.wikipedia.org/wiki/Mark-and-sweep)
*   [Wikipedia: Copying garbage collection](https://en.wikipedia.org/wiki/Copying_garbage_collection)
*   [Wikipedia: Generational garbage collection](https://en.wikipedia.org/wiki/Generational_garbage_collection)
*   [Wikipedia: Incremental garbage collection](https://en.wikipedia.org/wiki/Incremental_garbage_collection)
*   [Wikipedia: Concurrent garbage collection](https://en.wikipedia.org/wiki/Concurrent_garbage_collection)
*   [Wikipedia: Tracing garbage collection](https://en.wikipedia.org/wiki/Tracing_garbage_collection)
*   [Wikipedia: Memory leak](https://en.wikipedia.org/wiki/Memory_leak)
*   [Wikipedia: Buffer overflow](https://en.wikipedia.org/wiki/Buffer_overflow)
*   [Wikipedia: Stack buffer overflow](https://en.wikipedia.org/wiki/Stack_buffer_overflow)
*   [Wikipedia: Heap buffer overflow](https://en.wikipedia.org/wiki/Heap_buffer_overflow)
*   [Wikipedia: Format string bug](https://en.wikipedia.org/wiki/Format_string_bug)
*   [Wikipedia: Integer overflow](https://en.wikipedia.org/wiki/Integer_overflow)
*   [Wikipedia: Underflow](https://en.wikipedia.org/wiki/Underflow)
*   [Wikipedia: Division by zero](https://en.wikipedia.org/wiki/Division_by_zero)
*   [Wikipedia: Null pointer](https://en.wikipedia.org/wiki/Null_pointer)
*   [Wikipedia: Dangling pointer](https://en.wikipedia.org/wiki/Dangling_pointer)
*   [Wikipedia: Wild pointer](https://en.wikipedia.org/wiki/Wild_pointer)
*   [Wikipedia: Use-after-free](https://en.wikipedia.org/wiki/Use-after-free)
*   [Wikipedia: Double free](https://en.wikipedia.org/wiki/Double_free)
*   [Wikipedia: Memory corruption](https://en.wikipedia.org/wiki/Memory_corruption)
*   [Wikipedia: Data corruption](https://en.wikipedia.org/wiki/Data_corruption)
*   [Wikipedia: Checksum](https://en.wikipedia.org/wiki/Checksum)
*   [Wikipedia: Cyclic redundancy check](https://en.wikipedia.org/wiki/Cyclic_redundancy_check)
*   [Wikipedia: Hash function](https://en.wikipedia.org/wiki/Hash_function)
*   [Wikipedia: Cryptographic hash function](https://en.wikipedia.org/wiki/Cryptographic_hash_function)
*   [Wikipedia: Digital signature](https://en.wikipedia.org/wiki/Digital_signature)
*   [Wikipedia: Public-key cryptography](https://en.wikipedia.org/wiki/Public-key_cryptography)
*   [Wikipedia: Symmetric-key algorithm](https://en.wikipedia.org/wiki/Symmetric-key_algorithm)
*   [Wikipedia: Transport Layer Security](https://en.wikipedia.org/wiki/Transport_Layer_Security)
*   [Wikipedia: Secure Sockets Layer](https://en.wikipedia.org/wiki/Secure_Sockets_Layer)
*   [Wikipedia: Hypertext Transfer Protocol Secure](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol_Secure)
*   [Wikipedia: Firewall (computing)](https://en.wikipedia.org/wiki/Firewall_(computing))
*   [Wikipedia: Intrusion detection system](https://en.wikipedia.org/wiki/Intrusion_detection_system)
*   [Wikipedia: Intrusion prevention system](https://en.wikipedia.org/wiki/Intrusion_prevention_system)
*   [Wikipedia: Malware](https://en.wikipedia.org/wiki/Malware)
*   [Wikipedia: Virus (computer)](https://en.wikipedia.org/wiki/Computer_virus)
*   [Wikipedia: Worm (computer)](https://en.wikipedia.org/wiki/Computer_worm)
*   [Wikipedia: Trojan horse (computing)](https://en.wikipedia.org/wiki/Trojan_horse_(computing))
*   [Wikipedia: Ransomware](https://en.wikipedia.org/wiki/Ransomware)
*   [Wikipedia: Phishing](https://en.wikipedia.org/wiki/Phishing)
*   [Wikipedia: Social engineering (security)](https://en.wikipedia.org/wiki/Social_engineering_(security))
*   [Wikipedia: Denial-of-service attack](https://en.wikipedia.org/wiki/Denial-of-service_attack)
*   [Wikipedia: Distributed denial-of-service attack](https://en.wikipedia.org/wiki/Distributed_denial-of-service_attack)
*   [Wikipedia: SQL injection](https://en.wikipedia.org/wiki/SQL_injection)
*   [Wikipedia: Cross-site scripting](https://en.wikipedia.org/wiki/Cross-site_scripting)
*   [Wikipedia: Cross-site request forgery](https://en.wikipedia.org/wiki/Cross-site_request_forgery)
*   [Wikipedia: Man-in-the-middle attack](https://en.wikipedia.org/wiki/Man-in-the-middle_attack)
*   [Wikipedia: Zero-day (computing)](https://en.wikipedia.org/wiki/Zero-day_(computing))
*   [Wikipedia: Vulnerability (computing)](https://en.wikipedia.org/wiki/Vulnerability_(computing))
*   [Wikipedia: Exploit (computer security)](https://en.wikipedia.org/wiki/Exploit_(computer_security))
*   [Wikipedia: Patch (computing)](https://en.wikipedia.org/wiki/Patch_(computing))
*   [Wikipedia: Security update](https://en.wikipedia.org/wiki/Security_update)
*   [Wikipedia: Penetration test](https://en.wikipedia.org/wiki/Penetration_test)
*   [Wikipedia: Security audit](https://en.wikipedia.org/wiki/Security_audit)
*   [Wikipedia: Compliance (finance)](https://en.wikipedia.org/wiki/Compliance_(finance))
*   [Wikipedia: General Data Protection Regulation](https://en.wikipedia.org/wiki/General_Data_Protection_Regulation)
*   [Wikipedia: California Consumer Privacy Act](https://en.wikipedia.org/wiki/California_Consumer_Privacy_Act)
*   [Wikipedia: Health Insurance Portability and Accountability Act](https://en.wikipedia.org/wiki/Health_Insurance_Portability_and_Accountability_Act)
*   [Wikipedia: Payment Card Industry Data Security Standard](https://en.wikipedia.org/wiki/Payment_Card_Industry_Data_Security_Standard)
*   [Wikipedia: ISO/IEC 27001](https://en.wikipedia.org/wiki/ISO/IEC_27001)
*   [Wikipedia: NIST Cybersecurity Framework](https://en.wikipedia.org/wiki/NIST_Cybersecurity_Framework)
*   [Wikipedia: Common Vulnerabilities and Exposures](https://en.wikipedia.org/wiki/Common_Vulnerabilities_and_Exposures)
*   [Wikipedia: Common Weakness Enumeration](https://en.wikipedia.org/wiki/Common_Weakness_E