Haidhi Wiki - User contributions [en]

Cara install OKD

2026-10-28T04:17:44Z

SanzSkuy: Created page with "'''OKD''' adalah distribusi Kubernetes komunitas (upstream dari Red Hat OpenShift). Halaman ini mencatat langkah lengkap memasang '''OKD Single Node (SNO)''' sebagai satu VM di Proxmox VE, memakai '''Agent-based Installer''', untuk keperluan cluster dev. == Ringkasan == {| class="wikitable" ! Item !! Nilai |- | Versi OKD || <code>5.0.0-okd-scos.3</code> (stable) |- | OS node || CentOS Stream CoreOS (SCOS), ter-bake di ISO |- | Metode install || Agent-based Installer, t..."

'''OKD''' adalah distribusi Kubernetes komunitas (upstream dari Red Hat OpenShift). Halaman ini mencatat langkah lengkap memasang '''OKD Single Node (SNO)''' sebagai satu VM di Proxmox VE, memakai '''Agent-based Installer''', untuk keperluan cluster dev.

== Ringkasan ==
{| class="wikitable"
! Item !! Nilai
|-
| Versi OKD || <code>5.0.0-okd-scos.3</code> (stable)
|-
| OS node || CentOS Stream CoreOS (SCOS), ter-bake di ISO
|-
| Metode install || Agent-based Installer, topologi SNO
|-
| Hypervisor || Proxmox VE, standalone node <code>node-3</code>
|-
| Bridge jaringan || <code>vmbr3</code> (LAB) → subnet <code>192.168.90.0/24</code>
|-
| Gateway || <code>192.168.90.1</code> (MikroTik)
|-
| VM bastion (DNS) || <code>192.168.90.29</code>, AlmaLinux, dnsmasq
|-
| VM OKD (node) || <code>192.168.90.30</code>, hostname <code>okd-sno</code>
|-
| Cluster / base domain || <code>okd</code> / <code>lab.local</code>
|-
| Mesin kerja || Arch Linux (edit config + generate ISO)
|}

== Memilih topologi ==
* '''SNO (1 node)''': paling hemat resource, cocok untuk dev. Tidak ada HA, dan '''tidak bisa''' dikonversi ke cluster HA setelah terpasang.
* '''Compact cluster (3 node)''': ketiga node jadi master sekaligus worker. Lebih mirip production, tetap punya quorum etcd.
* '''2 node''': OKD punya topologi ''two-node with fencing'' (butuh BMC, tidak cocok untuk VM Proxmox) dan ''two control plane + arbiter'' (tetap 3 mesin, salah satunya arbiter kecil). Untuk lab, praktis pilih SNO atau 3 node.

Dipilih '''SNO''' supaya resource host tetap lega untuk VM lain.

== Arsitektur ==
<pre>
Arch Linux (laptop) ──WireGuard──► Proxmox (vmbr0, 192.168.11.x)
│ generate ISO
▼
Proxmox vmbr3 (LAB, 192.168.90.0/24)
├── VM bastion 192.168.90.29 → dnsmasq (DNS cluster)
└── VM OKD SNO 192.168.90.30 → seluruh cluster OKD
▲
gateway MikroTik 192.168.90.1 → internet (quay.io)
</pre>

'''Kenapa butuh bastion di dalam vmbr3?''' Host Proxmox tidak punya IP di <code>vmbr3</code>, dan laptop berada di jaringan lain (lewat WireGuard). Node OKD harus bisa menjangkau DNS-nya, jadi DNS diletakkan di VM yang satu subnet dengan node.

'''Bastion''' hanyalah istilah untuk mesin pembantu yang mengurus cluster (tempat <code>oc</code>, DNS, dsb.). DNS ini harus '''tetap hidup selama cluster hidup''', bukan hanya saat install, karena node memakai nama <code>api-int</code> untuk komunikasi internal.

== Kebutuhan resource ==
{| class="wikitable"
! VM !! vCPU !! RAM !! Disk
|-
| OKD SNO || 16 || 32 GB || 150 GB
|-
| Bastion (AlmaLinux minimal) || 1–2 || 1–2 GB || 10–20 GB
|}

Catatan:
* Spesifikasi minimal SNO di dokumentasi sekitar 8 vCPU / 16 GB, tapi 32 GB lebih nyaman.
* Di Proxmox, pemakaian RAM VM OKD terlihat sekitar 27 GiB saat install. Angka itu termasuk page cache dan tanpa guest agent, jadi lebih besar dari pemakaian riil. Cek angka asli dengan <code>oc adm top node</code>.

== Langkah 1: Siapkan binary di mesin kerja ==
Binary diambil dari GitHub Releases proyek OKD: <code>https://github.com/okd-project/okd/releases</code>

* Pilih rilis '''stable''' (tanpa label ''Pre-release'' dan tanpa <code>ec</code> di namanya).
* Download <code>openshift-install-linux-<tag>.tar.gz</code> dan <code>openshift-client-linux-<tag>.tar.gz</code>.

<syntaxhighlight lang="bash">
TAG=<tag-stable>
BASE=https://github.com/okd-project/okd/releases/download/$TAG
curl -LO $BASE/openshift-install-linux-$TAG.tar.gz
curl -LO $BASE/openshift-client-linux-$TAG.tar.gz

tar xzf openshift-install-linux-$TAG.tar.gz openshift-install
tar xzf openshift-client-linux-$TAG.tar.gz oc kubectl
sudo mv openshift-install oc kubectl /usr/local/bin/

openshift-install version
oc version --client
</syntaxhighlight>

'''Penting:''' <code>oc</code> '''wajib''' ada di <code>$PATH</code>, karena <code>openshift-install</code> memanggilnya saat membuat ISO.

Binary <code>openshift-install</code> terkunci ke satu rilis, jadi versi OKD yang terpasang sama dengan versi binary.

Install juga <code>nmstate</code> (menyediakan <code>nmstatectl</code>, dipakai untuk validasi IP statis):
<syntaxhighlight lang="bash">
yay -S nmstate # Arch (AUR)
nmstatectl --version
</syntaxhighlight>

Buat SSH key kalau belum ada:
<syntaxhighlight lang="bash">
ssh-keygen -t ed25519 -N ""
cat ~/.ssh/id_ed25519.pub
</syntaxhighlight>

== Langkah 2: Buat VM bastion (AlmaLinux) ==
AlmaLinux dipilih karena stabil dan support-nya panjang. Fedora kurang cocok untuk server yang hidup lama (siklus rilis cepat); CentOS Stream lebih sering berubah.

Setelan VM di Proxmox:
* Bridge '''<code>vmbr3</code>''', NIC VirtIO.
* '''CPU type <code>host</code>''' (lihat bagian Troubleshooting: kernel panic).
* RAM minimal 2 GB saat instalasi.
* Options → '''Start at boot''' aktif.

=== Kunci IP statis ===
<syntaxhighlight lang="bash">
nmcli -t -f NAME,DEVICE con show
sudo nmcli con mod ens18 ipv4.method manual \
ipv4.addresses 192.168.90.29/24 ipv4.gateway 192.168.90.1 \
ipv4.dns "192.168.90.29"
sudo nmcli con up ens18
sudo hostnamectl set-hostname marshall-okd-bastion
</syntaxhighlight>

DNS bastion diarahkan ke '''dnsmasq miliknya sendiri''' (<code>192.168.90.29</code>), bukan ke DNS publik. Kalau tidak, bastion tidak bisa resolve <code>api.okd.lab.local</code> dan <code>wait-for</code> tidak bisa memantau install.

Pastikan IP bastion dan IP node berada '''di luar pool DHCP''' MikroTik. Cek tanpa mengubah apa pun:
<pre>
/ip pool print
/ip dhcp-server lease print
</pre>

Cek IP node masih kosong:
<syntaxhighlight lang="bash">
ping -c2 192.168.90.30 # harus gagal
ip neigh | grep 192.168.90.30 # kosong atau FAILED
</syntaxhighlight>

== Langkah 3: DNS dengan dnsmasq ==
OKD membutuhkan tiga record:

{| class="wikitable"
! Record !! Fungsi
|-
| <code>api.okd.lab.local</code> || API cluster (port 6443), dipakai <code>oc</code> dan installer
|-
| <code>api-int.okd.lab.local</code> || API internal, dipakai node dan komponen cluster
|-
| <code>*.apps.okd.lab.local</code> || Ingress: web console, OAuth, dan semua aplikasi
|}

Di SNO, ketiganya mengarah ke IP node.

<syntaxhighlight lang="bash">
sudo dnf install -y dnsmasq bind-utils
sudo tee /etc/dnsmasq.d/okd.conf <<'EOF'
listen-address=192.168.90.29
bind-interfaces
server=1.1.1.1
server=8.8.8.8
address=/api.okd.lab.local/192.168.90.30
address=/api-int.okd.lab.local/192.168.90.30
address=/apps.okd.lab.local/192.168.90.30
EOF
</syntaxhighlight>

Penjelasan:
* <code>server=</code> adalah DNS upstream untuk nama di luar cluster (quay.io, dll.). dnsmasq hanya menjadi klien ke server itu, tidak mengubah konfigurasi router.
* <code>address=/apps.okd.lab.local/...</code> otomatis mencakup semua subdomain (wildcard).
* <code>listen-address</code> + <code>bind-interfaces</code> membuat dnsmasq hanya mendengarkan di IP tersebut, sehingga tidak bentrok dengan resolver lain.

Pastikan folder <code>.d</code> terbaca:
<syntaxhighlight lang="bash">
grep -n conf-dir /etc/dnsmasq.conf
# kalau tidak ada / masih dikomentari:
echo 'conf-dir=/etc/dnsmasq.d/,*.conf' | sudo tee -a /etc/dnsmasq.conf
</syntaxhighlight>

Jalankan dan uji:
<syntaxhighlight lang="bash">
sudo dnsmasq --test
sudo systemctl enable --now dnsmasq
sudo firewall-cmd --add-service=dns --permanent && sudo firewall-cmd --reload
sudo ss -lntup | grep ':53'
dig +short api.okd.lab.local @192.168.90.29 # → 192.168.90.30
dig +short quay.io @192.168.90.29 # harus ada jawaban
getent hosts api.okd.lab.local # dari bastion sendiri
</syntaxhighlight>

== Langkah 4: install-config.yaml ==
<syntaxhighlight lang="yaml">
apiVersion: v1
baseDomain: lab.local
metadata:
name: okd
compute:
- name: worker
replicas: 0
controlPlane:
name: master
replicas: 1
networking:
networkType: OVNKubernetes
machineNetwork:
- cidr: 192.168.90.0/24
clusterNetwork:
- cidr: 10.128.0.0/14
hostPrefix: 23
serviceNetwork:
- 172.30.0.0/16
platform:
none: {}
pullSecret: '{"auths":{"fake":{"auth":"aWQ6cGFzcwo="}}}'
sshKey: 'ssh-ed25519 AAAA... (isi ~/.ssh/id_ed25519.pub)'
</syntaxhighlight>

Catatan:
* <code>platform: none</code> dipakai karena Proxmox tidak punya integrasi native.
* '''Pull secret dummy''' (<code>id:pass</code> dalam base64) cukup untuk OKD, karena image diambil dari <code>quay.io/okd</code> yang publik. Pull secret asli Red Hat hanya perlu untuk OpenShift atau image dari <code>registry.redhat.io</code>.

== Langkah 5: agent-config.yaml ==
<syntaxhighlight lang="yaml">
apiVersion: v1alpha1
kind: AgentConfig
metadata:
name: okd
rendezvousIP: 192.168.90.30
hosts:
- hostname: okd-sno
role: master
interfaces:
- name: eth0
macAddress: BC:24:11:00:00:30
networkConfig:
interfaces:
- name: eth0
type: ethernet
state: up
mac-address: BC:24:11:00:00:30
ipv4:
enabled: true
dhcp: false
address:
- ip: 192.168.90.30
prefix-length: 24
dns-resolver:
config:
server:
- 192.168.90.29
routes:
config:
- destination: 0.0.0.0/0
next-hop-address: 192.168.90.1
next-hop-interface: eth0
table-id: 254
</syntaxhighlight>

Catatan:
* '''MAC address ditentukan sendiri''', lalu dipasang manual di NIC VM. Installer mencocokkan IP statis ke VM berdasarkan MAC.
* Aturan MAC: oktet pertama harus genap di digit keduanya (unicast). Prefix <code>BC:24:11</code> adalah prefix Proxmox.
* Nama interface <code>eth0</code> hanya label; pencocokan dilakukan lewat MAC.

== Langkah 6: Generate ISO ==
ISO '''tidak didownload''', melainkan dibuat oleh <code>openshift-install</code> dari dua YAML di atas. File YAML akan '''dikonsumsi''' (dihapus) saat generate, jadi simpan backup.

<syntaxhighlight lang="bash">
cd ~/okd
mkdir -p ~/okd-backup && cp install-config.yaml agent-config.yaml ~/okd-backup/
rm -rf cluster && mkdir cluster
cp install-config.yaml agent-config.yaml cluster/
openshift-install agent create image --dir cluster --log-level=info
</syntaxhighlight>

Hasil: <code>cluster/agent.x86_64.iso</code>, plus <code>cluster/auth/</code> (kubeconfig dan password kubeadmin).

* Tidak ada progress bar saat <code>Downloading base ISO</code>; tunggu sampai prompt kembali.
* Warning <code>Failed to extract base ISO from release payload</code> tidak fatal; installer jatuh ke jalur download.
* '''Setiap perubahan IP/DNS/MAC wajib generate ulang ISO''', karena konfigurasi ter-bake di dalamnya.

Salin folder <code>cluster/</code> ke bastion supaya <code>wait-for</code> dan <code>oc</code> bisa dijalankan dari sana.

== Langkah 7: Buat VM OKD di Proxmox ==
Upload ISO lewat UI Proxmox (storage → ISO Images → Upload), lalu Create VM:

{| class="wikitable"
! Tab !! Setelan !! Alasan
|-
| General || Start at boot || Cluster ikut hidup saat host reboot
|-
| OS || ISO <code>agent.x86_64.iso</code> ||
|-
| System || Machine <code>q35</code>, BIOS SeaBIOS || q35 chipset modern (opsional, i440fx juga bisa). Kalau OVMF, matikan Secure Boot
|-
| Disks || VirtIO SCSI single, 150 GB, SSD, '''Discard''' + '''SSD emulation''' || Discard (TRIM) mengembalikan ruang thin-provisioned ke host; opsional
|-
| CPU || 1 socket, 16 core, type '''<code>host</code>''' || '''Wajib.''' SCOS butuh instruksi CPU modern; tipe default bisa memicu crash
|-
| Memory || 32768 MB, '''Ballooning off''' || '''Penting.''' Kubernetes mengasumsikan RAM tetap; balloon bisa memicu OOM/eviction
|-
| Network || Bridge <code>vmbr3</code>, VirtIO, MAC '''<code>BC:24:11:00:00:30</code>''' || Harus sama persis dengan agent-config.yaml
|-
| Options → Boot Order || <code>scsi0</code> di atas CD-ROM || Setelah install, node boot dari disk, bukan installer lagi
|}

== Langkah 8: Install dan pantau ==
Start VM. Di Console Proxmox, tanda awal yang benar:
<pre>
ens18: 192.168.90.30
Ignition: user-provided config was applied
This host (192.168.90.30) is the rendezvous host.
</pre>

Urutan yang terlihat:
# <code>Waiting for services</code> → service installer naik satu per satu.
# <code>Installation cannot proceed: Cluster status: insufficient</code> → sementara, validasi host belum selesai.
# <code>Cluster installation in progress</code>.
# <code>Writing image to disk</code> 0–100%, lalu node reboot dari disk.
# Log <code>crio-... libcrun container</code> berulang → container cluster dinyalakan (normal).
# <code>Finished bootkube.service</code> → bootstrap selesai.

Pantau dari bastion:
<syntaxhighlight lang="bash">
cd ~/okd
openshift-install agent wait-for bootstrap-complete --dir cluster --log-level=info
openshift-install agent wait-for install-complete --dir cluster --log-level=info
</syntaxhighlight>

* Pesan <code>cluster bootstrap did not complete</code> tepat setelah ''Writing image to disk: 100%'' bisa muncul karena <code>wait-for</code> kehilangan kontak saat node reboot dari ISO ke disk. Jalankan ulang <code>wait-for</code> (aman, tidak mengganggu installer).
* Install aktual memakan sekitar '''1 jam''' (cluster <code>Available</code> sekitar 09:15 dari mulai 08:11).

Cek status langsung:
<syntaxhighlight lang="bash">
export KUBECONFIG=~/okd/cluster/auth/kubeconfig
curl -k https://api.okd.lab.local:6443/version
oc get clusterversion
oc get co
</syntaxhighlight>

Install sukses bila <code>clusterversion</code> <code>Available=True</code> dan semua cluster operator <code>Available=True, Progressing=False, Degraded=False</code>.

== Langkah 9: Akses web console ==
Password:
<syntaxhighlight lang="bash">
cat ~/okd/cluster/auth/kubeadmin-password
</syntaxhighlight>

Console tidak bisa dibuka lewat <code>IP:port</code>, karena router OKD memilih tujuan berdasarkan '''nama host'''. Di mesin yang menjalankan browser, tambahkan ke <code>/etc/hosts</code>:
<pre>
192.168.90.30 api.okd.lab.local console-openshift-console.apps.okd.lab.local oauth-openshift.apps.okd.lab.local
</pre>

Buka <code>https://console-openshift-console.apps.okd.lab.local</code>, login sebagai <code>kubeadmin</code>. Peringatan sertifikat (self-signed) normal.

Mesin itu juga harus bisa menjangkau <code>192.168.90.0/24</code> (misalnya lewat route WireGuard atau <code>sshuttle</code> via bastion).

Tes router tanpa browser:
<syntaxhighlight lang="bash">
curl -kI --resolve console-openshift-console.apps.okd.lab.local:443:192.168.90.30 \
https://console-openshift-console.apps.okd.lab.local
</syntaxhighlight>

== Langkah 10: Setelah install ==
* '''Snapshot VM OKD''' selagi bersih.
* '''Lepas ISO''' dari VM OKD (CD/DVD → Do not use any media).
* '''Autostart dan urutan boot''': bastion order 1, OKD order 2, beri jeda start.
* '''Simpan <code>cluster/auth/</code>''' di tempat aman.
* '''Storage class''': cluster baru di <code>platform: none</code> belum punya storage dinamis; PVC akan Pending sampai dipasang NFS / local-path / LVMS. Cek dengan <code>oc get sc</code>.
* '''Image registry''' (dev): <syntaxhighlight lang="bash">
oc patch configs.imageregistry.operator.openshift.io cluster --type merge \
--patch '{"spec":{"managementState":"Managed","storage":{"emptyDir":{}}}}'
</syntaxhighlight> (emptyDir: isi hilang saat pod restart, hanya untuk dev.)
* '''Keamanan''': jangan publikasikan console, OAuth, dan API ke internet selama masih memakai <code>kubeadmin</code>. Ganti dengan user admin biasa lewat OAuth.

== Publish aplikasi dengan domain sendiri (rencana) ==
Alur: <code>Internet → MikroTik NAT → nginx → router OKD (192.168.90.30:80) → app</code>

Route dengan domain sendiri:
<syntaxhighlight lang="bash">
oc create route edge myapp --service=myapp \
--hostname=app.domainku.com --insecure-policy=Allow
</syntaxhighlight>

nginx (TLS di nginx, teruskan header Host):
<syntaxhighlight lang="nginx">
location / {
proxy_pass http://192.168.90.30:80;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
</syntaxhighlight>

Tes sisi OKD: <code>curl -sI -H "Host: app.domainku.com" http://192.168.90.30</code>

== Troubleshooting (yang benar-benar terjadi) ==
{| class="wikitable"
! Gejala !! Penyebab !! Solusi
|-
| dnsmasq <code>start-limit-hit</code>, log: <code>failed to create listening socket for port 53: Address already in use</code> || Config di <code>/etc/dnsmasq.d/</code> tidak terbaca (Arch tidak mengaktifkan <code>conf-dir</code>), dnsmasq bind ke semua alamat dan bentrok dengan dnsmasq libvirt di <code>virbr0</code> || Tambahkan <code>conf-dir=/etc/dnsmasq.d/,*.conf</code>; gunakan <code>listen-address</code> + <code>bind-interfaces</code>
|-
| <code>exec: "nmstatectl": executable file not found in $PATH</code> || Paket nmstate belum terpasang || <code>yay -S nmstate</code>, atau jalankan installer di container Fedora
|-
| <code>exec: "oc": executable file not found in $PATH</code> || <code>oc</code> belum diekstrak/di-PATH || Ekstrak <code>openshift-client</code>, pindahkan ke <code>/usr/local/bin</code>
|-
| Node tidak bisa menjangkau DNS di laptop || Laptop (192.168.83.x, WiFi) tidak bisa dijangkau dari jaringan Proxmox (laptop masuk via WireGuard) || Pindahkan DNS ke VM bastion di <code>vmbr3</code>
|-
| Kernel panic AlmaLinux: <code>Attempted to kill init! exitcode=0x00007f00</code> || CPU type default Proxmox menyembunyikan instruksi x86-64-v2/v3 yang dibutuhkan Alma 9/10 || Ubah Processor → Type <code>host</code>
|-
| <code>wait-for</code> stuck lama di <code>Waiting for cluster install to initialize. Sleeping for 30 seconds</code> || Bastion tidak bisa resolve <code>api.okd.lab.local</code> (DNS bastion ke 1.1.1.1). Cluster sebenarnya sudah jadi || Arahkan DNS bastion ke dnsmasq-nya (<code>192.168.90.29</code>) atau tambah <code>/etc/hosts</code>. Cek dengan <code>getent hosts api.okd.lab.local</code>
|-
| Console tidak terbuka di laptop || Nama <code>*.apps</code> tidak dikenal, atau subnet 192.168.90.x tidak terjangkau || Tambah <code>/etc/hosts</code>, pastikan route ke 192.168.90.0/24
|}

Perintah debug yang berguna:
<syntaxhighlight lang="bash">
ssh core@192.168.90.30
sudo journalctl -b -f
sudo crictl ps
tail -n 60 ~/okd/cluster/.openshift_install.log
openshift-install agent wait-for bootstrap-complete --dir cluster --log-level=debug
</syntaxhighlight>

== Referensi ==
* [https://docs.okd.io/latest/installing/overview/ OKD installation overview]
* [https://docs.okd.io/4.21/installing/installing_sno/install-sno-preparing-to-install-sno.html Preparing to install OKD on a single node]
* [https://docs.okd.io/4.22/installing/installing_two_node_cluster/about-two-node-arbiter-installation.html OKD two control plane + arbiter]
* [https://okd.io/blog/2025/05/14/okd-4.19-and-4.20-release OKD 4.19 / 4.20 release (transisi ke SCOS)]
* [https://github.com/okd-project/okd/releases OKD releases (GitHub)]

DevOps

2026-10-28T04:17:00Z

SanzSkuy:

* [[Setup Jenkins]]
* [[Docker Registry & Rootless Docker]]
* [[Elasticsearch]]
* [[Postgres master & slave]]
* [[Cara buat monitoring server pake Grafana & Prometheus]]
* [[Deploy app bare-metal]]
* [[Cara install OKD]]

== Microk8s ==
* [[Microk8s: setup awal]]
* [[Microk8s: setup registry]]

Main Page

2026-10-26T09:57:51Z

SanzSkuy:

'''Haidhi Angkawijana Tedja''' 
Software Engineer @ Telkom Indonesia

I write everything that I learn

[https://github.com/haidhiSkuy GitHub] • [https://www.linkedin.com/in/haidhi-angkawijana-tedja/ LinkedIn] • haidhiangkawijana@gmail.com

== Research Interests ==
* Heterogeneous Computing
* High-Performance Computing (HPC)
* GPU/Accelerator Architectures
* Edge Computing
* Hardware-Software Co-design for AI Systems

== Education ==
=== South Tangerang Institute of Technology (ITTS) ===
''2021 – 2025''
* B.Sc. in Computer Science
* Undergraduate Thesis: "Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization"
* Advised by [https://id.wikipedia.org/wiki/Onno_W._Purbo Onno W. Purbo]

=== Riyadhussholihiin Islamic Boarding School ===
''2016 - 2021''
* Language Class (Arabic)
* Organisasi Santri Riyadhussholihin (OSRIY) & Baitul Qur'an
* Grade: Mumtaz (excellent)

== Work Experience ==
* Telkom Indonesia — AI & Backend Engineer ''(July 2024 – Present)''
* Meister Sinergi Indonesia (AERY) — ML/AI Engineer ''(October 2023 – Present)''
* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''
* Riyadhussholihiin Islamic Boarding School, Pandeglang — Teacher ''(July 2020 - July 2021)''

== Publication ==
* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608
* Tedja, H. A. (2025). Perbandingan Metode Vektorisasi Teks dan Algoritma Pembelajaran Mesin Klasik untuk Klasifikasi Teks Bahasa Arab. Journal of Computer and Information Systems Ampera, 7(3), 207–219. https://doi.org/10.51519/journalcisa.v7i3.793

== CV ==
* [https://drive.google.com/file/d/1y4H7s0E_N3XzCqi9o1iVPRj-KdLHOlEJ/view?usp=sharing CV_Haidhi_Angkawijana_Tedja.pdf]

== Categories ==
* [[Daftar Isi AI/ML|Artificial Intelligence, Machine Learning, & Data Science]]
* [[Daftar Isi Cybersecurity|Cybersecurity]]
* [[Linux & Operating System]]
* [[DevOps]]
* [[Web Assembly]]
* [[High-performance computing]]
* [[Programming, Software Engineering, etc]]

 
<pre>
Imam Syafi'i رحمه الله:

الْعِلْمُ صَيْدٌ وَالْكِتَابَةُ قَيْدُهُ * قَيِّدْ صُيُوْدَكَ بِالْحِبَالِ الْوَاثِقَهْ
فَمِنَ الْحَمَاقَةِ أَنْ تَصِيْدَ غَزَالَةً وَتَتْرُكَهَا بَيْنَ الْخَلاَئِقِ طَالِقَهْ

Knowledge is a quarry, and the written word its chain.
Bind thy quarry fast with cords unyielding.
For folly it is to hunt the stag,
Only to loose it once more among the wilds.
</pre>

Mikrotik 5: Bridge VLAN Filtering

2026-10-26T09:41:07Z

SanzSkuy: Created page with "== Tujuan == * Paham kapan cukup memakai VLAN interface di port, dan kapan butuh bridge VLAN filtering. * Paham tiga bagian bridge VLAN filtering: PVID, tabel VLAN, dan VLAN interface di atas bridge. * Bisa membuat access port, trunk ke switch, dan trunk ke server. * Bisa men-debug konfigurasi VLAN lewat CLI. == Konsep == === Router sebagai switch VLAN === * '''Part 4 (router-on-a-stick)''': VLAN diurus switch. Router hanya menerima satu kabel trunk. * '''Part 5''': ro..."

== Tujuan ==
* Paham kapan cukup memakai VLAN interface di port, dan kapan butuh bridge VLAN filtering.
* Paham tiga bagian bridge VLAN filtering: PVID, tabel VLAN, dan VLAN interface di atas bridge.
* Bisa membuat access port, trunk ke switch, dan trunk ke server.
* Bisa men-debug konfigurasi VLAN lewat CLI.

== Konsep ==

=== Router sebagai switch VLAN ===
* '''Part 4 (router-on-a-stick)''': VLAN diurus switch. Router hanya menerima satu kabel trunk.
* '''Part 5''': router '''sendiri''' menjadi switch VLAN. Setiap port bisa menjadi access atau trunk, dan router sekaligus menjadi gateway setiap VLAN.

=== Kapan butuh bridge? ===
{| class="wikitable"
! Situasi !! Pakai
|-
| Satu port membawa beberapa VLAN, dan setiap VLAN hanya ada di port itu || '''VLAN interface langsung di port''' (cara Part 4, paling simpel)
|-
| Satu VLAN tersebar di '''beberapa port''' router || '''Bridge + VLAN filtering'''
|}

Port-port hanya bisa "disambung" menjadi satu segmen lewat bridge ([[Belajar MikroTik Part 3|Part 3]]). Begitu port-port berada dalam satu bridge, cara memisahkan VLAN-nya adalah bridge VLAN filtering.

Analogi: VLAN interface di port = satu pipa dibagi beberapa jalur. Bridge VLAN filtering = gedung dengan banyak pintu, setiap pintu diberi label "khusus staff" atau "khusus tamu", dan pintu berlabel sama tetap tersambung satu sama lain.

'''VLAN yang sudah dipakai di satu port tetap bisa dipakai di port lain.''' Justru itu gunanya: VLAN 10 bisa ada di <code>ether2</code> dan <code>ether3</code> sekaligus, dan semua perangkatnya tetap satu network.

=== Tiga bagian + satu saklar ===
{| class="wikitable"
! # !! Bagian !! Menu !! Fungsi
|-
| 1 || '''PVID''' || Bridge → Ports || Frame '''polos''' yang masuk dari port ini dianggap milik VLAN berapa. Ini yang membuat port menjadi access port.
|-
| 2 || '''Tabel VLAN''' || Bridge → VLANs || Untuk setiap VLAN: port mana yang menjadi anggota, dan frame yang '''keluar''' dikirim tagged atau untagged. Ini daftar VLAN yang boleh lewat trunk.
|-
| 3 || '''VLAN interface di atas bridge''' || Interfaces → VLAN || Gateway Layer 3. Bridge sendiri harus menjadi anggota '''tagged''' di setiap VLAN ("port internal" ke otak router).
|-
| 4 || '''Saklar <code>vlan-filtering</code>''' || Bridge → Bridge → tab VLAN || Selama mati, semua aturan VLAN diabaikan. '''Nyalakan paling akhir.'''
|}

'''Frame Types''' di Bridge → Ports:
* Access port: <code>admit-only-untagged-and-priority-tagged</code> (frame bertag dari PC dibuang).
* Trunk port: <code>admit-only-vlan-tagged</code>.

'''Peringatan''': mengaktifkan <code>vlan-filtering</code> saat terhubung ke router lewat port anggota bridge bisa memutus koneksi Winbox. Di router produksi, selalu nyalakan '''Safe Mode''' dulu.

<pre>
┌──────────── CHR ─────────────┐
│ vlan10 … vlan70 (gateway) │ ← Layer 3
│ │ tagged │
│ ┌─ bridge-vlan ──────┐ │ ← "switch"
│ │ ether2-4 access │ │
│ │ ether5-6 trunk │ │
│ └────────────────────┘ │
│ ether1 (WAN, di luar bridge) │
└───────────────────────────────┘
</pre>

=== Pemakaian di dunia nyata ===
Di lab PC dicolok langsung ke port router agar sederhana. Di dunia nyata, port router biasanya tersambung ke:

{| class="wikitable"
! Port !! Tipe !! Tersambung ke !! Keterangan
|-
| ether2 || access 10 || Switch ruangan staff || Switch biasa (bahkan unmanaged). Semua yang dicolok otomatis VLAN 10.
|-
| ether3 || trunk 10, 20 || Access point || Dua SSID: <code>Kantor</code> (VLAN 10) dan <code>Kantor-Tamu</code> (VLAN 20). Satu kabel, dua jaringan.
|-
| ether4 || trunk 10, 20, 30 || Server Proxmox || VM ditempatkan di VLAN mana pun lewat satu kabel.
|-
| ether5 || access 30 || Switch CCTV || Semua kamera terkurung di VLAN 30.
|}

Di kantor besar, router sering hanya memakai 1–2 port trunk ke switch inti. Switch MikroTik (CRS) dikonfigurasi dengan '''cara yang sama persis'''.

'''Homelab''': pola ini juga populer di rumah, misalnya VLAN keluarga, VLAN lab/server, VLAN IoT (smart TV, CCTV murah), dan VLAN tamu. Ingat: VLAN saja tidak mengisolasi, karena router tetap me-routing antar VLAN. Isolasi dibutuhkan lewat firewall ([[Belajar MikroTik Part 6|Part 6]]).

== Lab ==

=== Topologi ===
<pre>
[NAT]
│ ether1 (WAN)
[CHR] ── bridge-vlan
ether2 ether3 ether4 ether5 ether6
VLAN10 VLAN10 VLAN20 trunk 30+40 trunk 50+60+70
│ │ │ │ │
Staff1 Staff2 Tamu [Switch1] [Proxmox]
/ \ eth0.50/.60/.70
PC-30 PC-40
</pre>

{| class="wikitable"
! VLAN !! Subnet !! Gateway !! Lokasi
|-
| 10 || <code>172.16.10.0/24</code> || <code>.1</code> || ether2, ether3 (access)
|-
| 20 || <code>172.16.20.0/24</code> || <code>.1</code> || ether4 (access)
|-
| 30, 40 || <code>172.16.30.0/24</code>, <code>172.16.40.0/24</code> || <code>.1</code> || ether5 (trunk ke switch)
|-
| 50, 60, 70 || <code>172.16.50.0/24</code>, <code>.60.</code>, <code>.70.</code> || <code>.1</code> || ether6 (trunk ke server)
|}

PC memakai container <code>lab-ubuntu</code> (lihat [[Belajar MikroTik Lampiran: Linux Networking|lampiran Linux]]) atau VPCS.

=== 0. Persiapan ===
* Host: <code>virsh net-start default</code> dan aturan <code>DOCKER-USER</code> ([[Belajar MikroTik Part 1|Part 1]]).
* Project baru, identity, NAT masquerade di <code>ether1</code>, DNS Allow Remote Requests ([[Belajar MikroTik Part 4|Part 4]]).
* Backup: snapshot GNS3 atau <code>/export file=...</code>.

=== 1. Access port (ether2–ether4) ===
'''Bridge''': Bridge → Bridge → New, Name <code>bridge-vlan</code>, '''VLAN Filtering belum dicentang'''.

'''Ports''': Bridge → Ports → New
{| class="wikitable"
! Interface !! PVID !! Frame Types
|-
| <code>ether2</code> || 10 || admit only untagged and priority tagged
|-
| <code>ether3</code> || 10 || admit only untagged and priority tagged
|-
| <code>ether4</code> || 20 || admit only untagged and priority tagged
|}

'''Tabel VLAN''': Bridge → VLANs → New
{| class="wikitable"
! VLAN IDs !! Tagged !! Untagged
|-
| 10 || <code>bridge-vlan</code> || <code>ether2</code>, <code>ether3</code>
|-
| 20 || <code>bridge-vlan</code> || <code>ether4</code>
|}

'''Gateway''': VLAN interface di '''<code>bridge-vlan</code>''' (bukan di port fisik), IP, dan DHCP per VLAN.

'''Saklar''': Bridge → Bridge → <code>bridge-vlan</code> → tab VLAN → centang '''VLAN Filtering'''.

=== 2. Trunk ke switch (ether5, VLAN 30 + 40) ===
Switch GNS3: port 0 <code>dot1q</code> (ke <code>ether5</code>), port 1 <code>access 30</code> (PC-30), port 2 <code>access 40</code> (PC-40).

Di router:
* Bridge → Ports: <code>ether5</code>, Frame Types '''admit only VLAN tagged''', PVID dibiarkan default.
* Bridge → VLANs: VLAN 30 dan 40, Tagged <code>bridge-vlan</code> + <code>ether5</code>, Untagged kosong.
* VLAN interface <code>vlan30</code>, <code>vlan40</code> di <code>bridge-vlan</code>, IP, DHCP.

Access port menerima frame '''polos''' dan memakai PVID untuk menentukan VLAN. Trunk menerima frame '''bertag''' karena VLAN-nya sudah tertulis di tag.

=== 3. Trunk ke server (ether6, VLAN 50 + 60 + 70) ===
<syntaxhighlight lang="text">
/interface bridge port add bridge=bridge-vlan interface=ether6 frame-types=admit-only-vlan-tagged

/interface bridge vlan
add bridge=bridge-vlan vlan-ids=50 tagged=bridge-vlan,ether6
add bridge=bridge-vlan vlan-ids=60 tagged=bridge-vlan,ether6
add bridge=bridge-vlan vlan-ids=70 tagged=bridge-vlan,ether6

/interface vlan
add name=vlan50 interface=bridge-vlan vlan-id=50
add name=vlan60 interface=bridge-vlan vlan-id=60
add name=vlan70 interface=bridge-vlan vlan-id=70

/ip address
add address=172.16.50.1/24 interface=vlan50 comment=VLAN50-proxmox
add address=172.16.60.1/24 interface=vlan60 comment=VLAN60-proxmox
add address=172.16.70.1/24 interface=vlan70 comment=VLAN70-proxmox

/ip pool
add name=pool50 ranges=172.16.50.100-172.16.50.200
add name=pool60 ranges=172.16.60.100-172.16.60.200
add name=pool70 ranges=172.16.70.100-172.16.70.200

/ip dhcp-server network
add address=172.16.50.0/24 gateway=172.16.50.1 dns-server=172.16.50.1
add address=172.16.60.0/24 gateway=172.16.60.1 dns-server=172.16.60.1
add address=172.16.70.0/24 gateway=172.16.70.1 dns-server=172.16.70.1

/ip dhcp-server
add name=server50 interface=vlan50 address-pool=pool50
add name=server60 interface=vlan60 address-pool=pool60
add name=server70 interface=vlan70 address-pool=pool70
</syntaxhighlight>

'''Menambah trunk untuk VLAN yang sudah ada''' cukup menambahkan port ke kolom Tagged. Hati-hati: <code>set tagged=...</code> '''menimpa''' daftar lama, sehingga port yang sudah ada harus ditulis ulang:
<syntaxhighlight lang="text">
/interface bridge vlan set [find vlan-ids=30] tagged=bridge-vlan,ether5,ether6
</syntaxhighlight>

=== 4. Sisi server (container Linux) ===
<syntaxhighlight lang="bash">
ip link set eth0 up
for v in 50 60 70; do
ip link add link eth0 name eth0.$v type vlan id $v
ip link set eth0.$v up
dhclient -v eth0.$v
done
ip -br addr
</syntaxhighlight>

Hasil:
<pre>
eth0.50@eth0 UP 172.16.50.200/24
eth0.60@eth0 UP 172.16.60.200/24
eth0.70@eth0 UP 172.16.70.200/24
eth0 UP
</pre>

* <code>RTNETLINK answers: File exists</code> saat <code>dhclient</code> kedua/ketiga itu normal: Linux hanya memakai satu default gateway di tabel routing utama.
* Ctrl+C di tengah loop menghentikan '''seluruh''' loop. VLAN berikutnya harus dicoba manual.
* Baris <code>xid: warning ...</code> aman diabaikan.

=== Padanan di Proxmox sungguhan ===
<syntaxhighlight lang="text">
auto vmbr0
iface vmbr0 inet manual
bridge-ports eno1
bridge-stp off
bridge-fd 0
bridge-vlan-aware yes
bridge-vids 2-4094

auto vmbr0.50
iface vmbr0.50 inet static
address 172.16.50.20/24
gateway 172.16.50.1
</syntaxhighlight>
* <code>bridge-vlan-aware yes</code> = bridge Proxmox juga memakai VLAN filtering, konsepnya sama dengan <code>bridge-vlan</code> di MikroTik.
* <code>vmbr0.50</code> = IP manajemen host, statis di range server.
* Setiap VM: Bridge <code>vmbr0</code> + '''VLAN Tag''' di setting network VM.

== Verifikasi ==
* Setiap PC/VM mendapat IP sesuai VLAN-nya dan bisa <code>ping 8.8.8.8</code>.
* <code>trace</code> dalam satu VLAN langsung sampai; antar VLAN lewat gateway.
* '''Bridge → VLANs''': keanggotaan tagged/untagged sesuai rencana.
* '''Bridge → Hosts''': MAC setiap perangkat beserta port dan VLAN-nya.

Entri dinamis seperti <code>VLAN 1 ;;; added by pvid</code> di tabel VLAN itu normal: bridge sendiri punya PVID default 1.

== Masalah yang ditemui ==

=== VLAN interface berflag R tapi parameternya salah ===
Ketiga kasus di bawah sama-sama terlihat normal di <code>print</code> biasa. Flag '''R''' hanya berarti "interface hidup", bukan "konfigurasinya benar". Masalahnya baru terlihat di <code>print detail</code>.

{| class="wikitable"
! Kasus !! Temuan di <code>print detail</code> !! Penyebab !! Perbaikan
|-
| PC-30 & PC-40 tidak dapat IP || <code>vlan30</code> dan <code>vlan40</code>: <code>vlan-id=1</code> || Kolom VLAN ID terlewat, memakai default || <code>/interface vlan set vlan30 vlan-id=30</code>
|-
| PC-40 tidak dapat IP || <code>vlan40</code>: <code>use-service-tag=yes</code> || Checkbox '''Use Service Tag''' tercentang. Itu mode QinQ (penanda <code>0x88a8</code>), sedangkan switch mengirim tag biasa <code>0x8100</code>. || <code>... vlan-id=40 use-service-tag=no</code>
|-
| VLAN 50 jalan, VLAN 60 tidak || <code>vlan60</code>: <code>interface=ether1</code>, MAC sama dengan <code>ether1</code> || Dropdown Interface terpilih port WAN || <code>/interface vlan set vlan60 interface=bridge-vlan</code>
|}

Efek samping VLAN interface ber-ID 1 di atas bridge: muncul entri dinamis <code>VLAN 1 ;;; added by vlan on bridge</code> di tabel VLAN.

=== Diagnosis cepat ===
'''Kalau satu VLAN jalan dan VLAN lain tidak''' di trunk yang sama, jalur fisik dan trunk sudah benar. Fokus ke konfigurasi khusus VLAN yang gagal.

'''Menentukan layer masalah''': jalankan DHCP di client, sementara di router:
<syntaxhighlight lang="text">
/tool torch interface=vlan60
/tool sniffer quick interface=ether6
</syntaxhighlight>
* Ada traffic di <code>vlanXX</code> → paket sampai, masalah di DHCP/IP.
* Kosong → masalah di VLAN ID, interface induk, atau tabel bridge VLAN.

'''Perintah pengecekan lengkap'''
<syntaxhighlight lang="text">
/interface vlan print detail
/interface bridge print
/interface bridge port print
/interface bridge vlan print
/ip address print
/ip pool print
/ip dhcp-server print
/ip dhcp-server network print
/ip dhcp-server lease print
/log print where topics~"dhcp"
</syntaxhighlight>

== Checklist VLAN baru ==
# '''Bridge → VLANs''': VLAN ID; <code>bridge-vlan</code> + port trunk di Tagged; access port di Untagged.
# '''Interfaces → VLAN''': cek '''vlan-id''', '''interface = bridge-vlan''', '''use-service-tag = no'''.
# '''IP → Addresses''': gateway <code>.1</code>.
# '''DHCP''': gateway/DNS di Networks.
# Langsung jalankan <code>/interface vlan print detail</code>.

'''Tips''': simpan blok CLI VLAN sebagai template, ganti angkanya, lalu copy-paste. Sebagian besar kesalahan di lab ini terjadi saat mengisi form GUI.

== Latihan ==
# '''Tebak dulu''': hapus <code>ether6</code> dari Tagged di VLAN 60. Di container, <code>dhclient -r eth0.60</code> lalu <code>dhclient -v eth0.60</code>. Apa yang terjadi? Apakah VLAN 50 dan 70 ikut terdampak?
# '''IP manajemen statis''': lepas DHCP di <code>eth0.50</code>, pasang <code>172.16.50.20/24</code> dengan gateway <code>172.16.50.1</code>, sampai container bisa <code>ping 8.8.8.8</code> lewat VLAN 50.
# '''Detektif''': di '''Bridge → Hosts''', MAC container muncul berapa kali dan di VLAN apa saja? Kenapa satu MAC bisa muncul beberapa kali?
# '''Tebak dulu''': hapus <code>bridge-vlan</code> dari Tagged di VLAN 20 (biarkan <code>ether4</code> untagged). Apakah Tamu masih bisa mendapat IP? Ping gateway? Ping Staff1?

== Catatan ==
Bridge VLAN filtering sudah melampaui cakupan dasar MTCNA dan lebih dekat ke materi switching. Kesalahan di lab ini hampir semuanya salah input, bukan salah konsep. Kemampuan yang paling berguna bukan menghafal menu, tapi melacak kenapa sesuatu tidak berjalan.

== Ringkasan ==
* Satu VLAN di satu port → VLAN interface di port. Satu VLAN di banyak port → bridge VLAN filtering.
* PVID = VLAN untuk frame polos yang masuk. Tabel VLAN = keanggotaan dan tagged/untagged saat keluar.
* VLAN interface (gateway) ditempel di bridge, dan bridge harus tagged di setiap VLAN.
* Nyalakan <code>vlan-filtering</code> paling akhir, dengan Safe Mode di router produksi.
* Flag R bukan jaminan benar: biasakan <code>print detail</code>.

Networking

2026-10-26T09:41:01Z

SanzSkuy:

= Networking =
* [[Model OSI]]
* [[Lapisan Transport (TCP dan UDP)]]
* [[Kelas Alamat IP]]
* [[Subnetting 1]]
* [[VLSM]]
* [[Magic Number Method & Subnetting Jaringan Besar]]
* [[Subnetting: Contoh Oktet ke-3 vs ke-4]]
* [[Private IP Address (RFC 1918)]]
* [[Ethernet & Layer 2 (Data Link)]]
* [[Media Koneksi Ethernet (Layer 1)]]
* [[Perangkat Jaringan: Hub, Switch, dan Router]]

= Mikrotik =
* [[Mikrotik 1: Install GNS3 Arch Linux]]
* [[Mikrotik 2: Kantor Mini]]
* [[Mikrotik 3: Bridge]]
* [[Mikrotik 4: VLAN]]
* [[Mikrotik 5: Bridge VLAN Filtering]]

= Cisco =
* [[Cisco IOS]]
* [[Perintah Dasar Cisco IOS]]

== Cisco Lab ==
* [[Lab 0.1 - Basic Device Hardening]]

Mikrotik 4: VLAN

2026-10-26T06:33:34Z

SanzSkuy: Created page with "== Tujuan == * Paham VLAN, tag 802.1Q, access port, dan trunk port. * Bisa membuat VLAN interface dan gateway per VLAN di RouterOS. * Bisa melihat tag VLAN di Wireshark. * Paham dua kesalahan klasik: VLAN ditentukan port switch, dan trunk yang tidak sepakat di kedua ujung. == Konsep == === Masalah yang diselesaikan VLAN === Tanpa VLAN, setiap segmen butuh port router, switch, dan jalur kabel sendiri. Lima segmen (staff, tamu, CCTV, server, manajemen) berarti lima port..."

== Tujuan ==
* Paham VLAN, tag 802.1Q, access port, dan trunk port.
* Bisa membuat VLAN interface dan gateway per VLAN di RouterOS.
* Bisa melihat tag VLAN di Wireshark.
* Paham dua kesalahan klasik: VLAN ditentukan port switch, dan trunk yang tidak sepakat di kedua ujung.

== Konsep ==

=== Masalah yang diselesaikan VLAN ===
Tanpa VLAN, setiap segmen butuh port router, switch, dan jalur kabel sendiri. Lima segmen (staff, tamu, CCTV, server, manajemen) berarti lima port router, lima switch, lima kabel.

'''VLAN (Virtual LAN)''' memecah satu switch fisik menjadi beberapa switch virtual yang terisolasi di Layer 2. Setiap VLAN punya nomor ('''VLAN ID''', 1–4094). Perangkat di VLAN berbeda tidak bisa saling meng-ARP, persis seperti berada di switch berbeda.

=== Tag 802.1Q ===
Satu kabel bisa membawa banyak VLAN karena setiap frame diberi '''tag''' (label) berisi VLAN ID. Standarnya '''IEEE 802.1Q'''.

<pre>
Frame biasa: [Dst MAC][Src MAC][Type][ Data ][FCS]
Frame 802.1Q: [Dst MAC][Src MAC][TAG][Type][ Data ][FCS]
└ 4 byte tambahan
</pre>

Isi tag (4 byte):
{| class="wikitable"
! Bagian !! Ukuran !! Fungsi
|-
| '''TPID''' || 16 bit || Penanda <code>0x8100</code>: "frame ini bertag 802.1Q"
|-
| '''PRI''' (PCP) || 3 bit || Prioritas untuk QoS (misalnya VoIP didahulukan)
|-
| '''DEI''' || 1 bit || Tanda boleh dibuang lebih dulu saat padat
|-
| '''VLAN ID''' || 12 bit || Nomor VLAN (212 = 4096, dipakai 1–4094)
|}

Contoh di Wireshark:
<pre>
Ethernet II, Src: 00:50:79:66:68:00, Dst: ...
802.1Q Virtual LAN, PRI: 0, DEI: 0, ID: 10 ← tag
Internet Protocol Version 4, Src: 172.16.10.x, Dst: 8.8.8.8
</pre>

=== Access port vs trunk port ===
{| class="wikitable"
! !! Access port !! Trunk port
|-
| Membawa || '''Satu''' VLAN || '''Banyak''' VLAN
|-
| Frame || '''Untagged''' || '''Tagged'''
|-
| Tersambung ke || PC, printer, CCTV || Switch lain, router, server Proxmox
|}

'''PC tidak tahu apa-apa soal VLAN.''' PC mengirim frame polos. Switch menempelkan tag saat frame masuk dari access port, dan melepas tag saat frame keluar ke access port. Tag hanya hidup di jalur trunk.

'''Native VLAN''': VLAN yang lewat trunk '''tanpa tag'''. Di switch GNS3, kolom VLAN pada port <code>dot1q</code> adalah native VLAN (default <code>1</code>).

=== Router-on-a-stick ===
Setiap VLAN adalah segmen terpisah, sehingga butuh '''subnet dan gateway sendiri'''. Router cukup tersambung ke switch dengan '''satu kabel trunk''', lalu membuat satu '''VLAN interface''' per VLAN (misalnya <code>vlan10</code>, <code>vlan20</code>). Setiap VLAN interface diberi IP gateway. Satu kabel, banyak gateway.

=== Keuntungan dan harga yang dibayar ===
'''Keuntungan'''
* Hemat port router: satu port trunk bisa membawa banyak segmen.
* Hemat switch: satu switch fisik dipakai bersama semua segmen.
* Hemat kabel antar lantai/ruangan: cukup satu trunk per switch.
* Fleksibel: memindahkan PC ke segmen lain cukup mengubah setting port switch.

'''Harga yang dibayar'''
* '''Bandwidth trunk dibagi''' semua VLAN. Traffic antar VLAN naik ke router lewat trunk lalu turun lagi lewat trunk yang sama.
* '''Single point of failure''': trunk putus = semua VLAN di switch itu putus.
* '''Butuh managed switch'''. Switch unmanaged tidak mengerti tag.
* CPU router mengerjakan semua routing antar VLAN.

'''Solusi umum''': trunk di port cepat (SFP+ 10 Gbps), '''bonding/LACP''' (beberapa kabel menjadi satu trunk dengan cadangan), atau '''switch Layer 3''' untuk routing antar VLAN di kantor besar.

=== Managed vs unmanaged switch ===
{| class="wikitable"
! !! Unmanaged !! Managed (termasuk "smart/easy smart")
|-
| Setup || Colok langsung jalan || Colok langsung jalan, tapi bisa dikonfigurasi
|-
| IP / web UI || Tidak ada || Ada (web UI, SSH/CLI, port console)
|-
| VLAN || Tidak || Ya
|-
| Fitur lain || – || Monitoring per port, port mirroring, LACP, STP, limit bandwidth
|-
| Contoh || Switch 5–8 port murah || MikroTik CRS/CSS, Cisco Catalyst, TP-Link Easy Smart/JetStream, UniFi
|}

Managed switch baru '''berperilaku seperti unmanaged''': semua port default <code>access VLAN 1</code>.

'''Jebakan di kantor'''
* Unmanaged switch di '''access port VLAN 10''' → semua perangkat di switch kecil itu masuk VLAN 10. Normal dan sering disengaja.
* Unmanaged switch di '''trunk port''' → perangkat hanya mendapat native VLAN, sementara frame bertag VLAN lain ikut diteruskan. Gejalanya: "PC di ruangan ini dapat IP dari segmen yang salah."

== Lab ==

=== Topologi ===
<pre>
[NAT]
│
ether1 (WAN, DHCP client)
│
[CHR]
ether2
║ trunk (VLAN 10 + 20)
║
[Switch1]
port1 port2 port3
VLAN10 VLAN10 VLAN20
│ │ │
Staff1 Staff2 Tamu

vlan10 → 172.16.10.1/24 (staff)
vlan20 → 172.16.20.1/24 (tamu)
</pre>

'''Konvensi alamat''': range privat <code>172.16.0.0/12</code>, dengan oktet ketiga = VLAN ID (VLAN 10 → <code>172.16.10.0/24</code>). Memudahkan saat VLAN sudah puluhan.

=== 1. Persiapan host dan project ===
<syntaxhighlight lang="bash">
sudo virsh net-start default 2>/dev/null
sudo iptables -I DOCKER-USER -i virbr0 -j ACCEPT
sudo iptables -I DOCKER-USER -o virbr0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
</syntaxhighlight>
* GNS3: '''File → New blank project''' (contoh nama: <code>fase2-vlan</code>).
* Perangkat: NAT, MikroTik CHR, Ethernet switch, 3 VPCS (beri nama Staff1, Staff2, Tamu).

=== 2. Konfigurasi switch GNS3 ===
Nyalakan '''View → Show interface labels''' untuk melihat nomor port tiap kabel, lalu klik kanan switch → '''Configure'''.

Untuk setiap port: klik barisnya di daftar '''Ports''', isi '''VLAN''' dan '''Type''', lalu klik '''Add''' (menimpa setting port dengan nomor yang sama). Akhiri dengan '''Apply → OK'''. Kalau perubahan tidak tersimpan, stop switch dulu.

{| class="wikitable"
! Port !! Ke !! VLAN !! Type
|-
| 0 || CHR <code>ether2</code> || 1 || <code>dot1q</code>
|-
| 1 || Staff1 || 10 || <code>access</code>
|-
| 2 || Staff2 || 10 || <code>access</code>
|-
| 3 || Tamu || 20 || <code>access</code>
|}

<code>dot1q</code> = trunk 802.1Q. QinQ EtherType dibiarkan <code>0x8100</code> (hanya dipakai pada type <code>qinq</code>). Sesuaikan nomor port dengan label kabel.

=== 3. Setup dasar CHR ===
Di console:
<syntaxhighlight lang="text">
/system identity set name=router-vlan
/ip address print
</syntaxhighlight>
Catat IP WAN di <code>ether1</code>, connect Winbox, lalu:
* '''IP → Firewall → NAT''': <code>srcnat</code>, Out. Interface <code>ether1</code>, <code>masquerade</code>
* '''IP → DNS''': centang '''Allow Remote Requests'''
* Tes: <code>/ping 8.8.8.8 count=3</code>

=== 4. VLAN interface dan gateway ===
{| class="wikitable"
! Winbox !! Isian !! CLI
|-
| '''Interfaces → VLAN''' → New || <code>vlan10</code>, VLAN ID <code>10</code>, Interface <code>ether2</code> || <code>/interface vlan add name=vlan10 vlan-id=10 interface=ether2</code>
|-
| '''Interfaces → VLAN''' → New || <code>vlan20</code>, VLAN ID <code>20</code>, Interface <code>ether2</code> || <code>/interface vlan add name=vlan20 vlan-id=20 interface=ether2</code>
|-
| '''IP → Addresses''' → New || <code>172.16.10.1/24</code> di <code>vlan10</code>, comment <code>VLAN10-staff</code> || <code>/ip address add address=172.16.10.1/24 interface=vlan10 comment=VLAN10-staff</code>
|-
| '''IP → Addresses''' → New || <code>172.16.20.1/24</code> di <code>vlan20</code>, comment <code>VLAN20-tamu</code> || <code>/ip address add address=172.16.20.1/24 interface=vlan20 comment=VLAN20-tamu</code>
|}

<code>ether2</code> sendiri '''tidak diberi IP'''. Ia hanya kabel trunk, sedangkan kerja Layer 3 ada di <code>vlan10</code> dan <code>vlan20</code>. Sama seperti aturan bridge: IP di interface logis, bukan di port fisik.

=== 5. DHCP per VLAN ===
Setiap VLAN butuh '''pool, network, dan server sendiri''' karena subnetnya berbeda.

'''Lewat DHCP Setup''' (jalankan untuk <code>vlan10</code>, lalu <code>vlan20</code>): wizard membuat pool otomatis. Ubah '''Addresses to Give Out''' menjadi <code>.100–.200</code> agar <code>.2–.99</code> tetap kosong untuk perangkat statis.

'''Manual''':
{| class="wikitable"
! Bagian !! VLAN 10 !! VLAN 20
|-
| Pool || <code>172.16.10.100-172.16.10.200</code> || <code>172.16.20.100-172.16.20.200</code>
|-
| Network || <code>172.16.10.0/24</code>, gateway & DNS <code>172.16.10.1</code> || <code>172.16.20.0/24</code>, gateway & DNS <code>172.16.20.1</code>
|-
| Server || Interface <code>vlan10</code> || Interface <code>vlan20</code>
|}

'''Periksa''': pool di subnet yang benar, gateway/DNS = <code>.1</code>, server menempel di <code>vlan10</code>/<code>vlan20</code> (bukan <code>ether2</code>). Rule NAT tidak perlu diubah.

== Verifikasi ==
<syntaxhighlight lang="text">
ip dhcp
show ip
ping 8.8.8.8
trace <IP PC lain>
</syntaxhighlight>
* Staff1 dan Staff2 mendapat <code>172.16.10.x</code>, Tamu mendapat <code>172.16.20.x</code>.
* <code>trace</code> Staff1 → Staff2: langsung sampai (satu VLAN, di-switch).
* <code>trace</code> Staff1 → Tamu: lewat <code>172.16.10.1</code> (beda VLAN, di-route).

Ketiganya tersambung ke '''switch fisik yang sama''', tapi VLAN memisahkan mereka di Layer 2.

Kalau PC hanya menampilkan "DDD", periksa dulu kecocokan nomor port switch dengan label kabel.

== Latihan dan pembahasan ==

=== Soal 1: melihat tag ===
'''Soal''': capture Wireshark di kabel CHR ↔ Switch1 (trunk) dan Switch1 ↔ Staff1 (access), lalu ping dari Staff1. Di mana ada tag 802.1Q? VLAN ID-nya berapa?

'''Pembahasan'''
* '''Trunk''': ada baris <code>802.1Q Virtual LAN</code> dengan '''ID 10 dan ID 20'''. Meskipun ping hanya dari Staff1 (VLAN 10), traffic Tamu (ARP, DHCP renew) juga lewat kabel yang sama. Bukti satu trunk membawa banyak VLAN.
* '''Access''': tidak ada tag, frame polos.
* Alur: Staff1 mengirim frame polos → Switch1 menempelkan tag <code>ID: 10</code> → CHR membaca tag dan menyerahkan frame ke <code>vlan10</code>. Arah balik, switch melepas tag sebelum frame sampai ke Staff1.

=== Soal 2: menambah VLAN CCTV ===
'''Soal''': buat VLAN 30 (<code>172.16.30.0/24</code>) dengan PC4 sampai bisa internetan.

'''Pembahasan'''
{| class="wikitable"
! Di mana !! Perubahan
|-
| Router || '''Interfaces → VLAN''': <code>vlan30</code>, ID <code>30</code>, di <code>ether2</code>
|-
| Router || '''IP → Addresses''': <code>172.16.30.1/24</code> di <code>vlan30</code>
|-
| Router || DHCP: pool, network (gateway/DNS <code>172.16.30.1</code>), server di <code>vlan30</code>
|-
| Router || NAT: tidak perlu diubah
|-
| Switch || Port PC4: <code>access</code> VLAN <code>30</code>
|-
| Switch || Port trunk: tidak diubah (di GNS3)
|}

* '''Jangan lupa IP gateway''' di <code>vlan30</code>. DHCP Setup bisa berjalan tanpanya, tapi PC akan mendapat gateway yang tidak ada di router.
* '''Trunk di GNS3''' otomatis membawa semua VLAN. Di banyak switch sungguhan (termasuk MikroTik), trunk harus '''didaftarkan VLAN mana saja yang boleh lewat'''. Lupa menambahkan VLAN baru ke trunk = PC di VLAN itu "DDD" terus, padahal konfigurasi lain sudah benar.
* Beri comment <code>VLAN30-cctv</code> di semua objek terkait.

=== Soal 3: memindahkan VLAN tanpa menyentuh PC ===
'''Soal''': ubah port Tamu dari access VLAN 20 menjadi access VLAN 10, tanpa mengubah PC. Lalu <code>ip dhcp -x</code> dan <code>ip dhcp</code>.

'''Hasil''': Tamu mendapat <code>172.16.10.x</code>.

'''Pembahasan''': '''VLAN sebuah PC ditentukan oleh port switch tempat ia tersambung.''' PC tidak tahu dan tidak bisa memilih.
* '''Enak''': memindahkan karyawan ke segmen lain cukup mengubah port switch.
* '''Bahaya''': siapa pun yang mencolok laptop ke port staff langsung masuk jaringan staff. Keamanan port fisik penting. Solusi lanjutannya '''802.1X''' (perangkat harus login sebelum port dibuka), yaitu fitur di menu '''Dot1X''' RouterOS.

=== Soal 4: trunk yang salah ===
'''Soal''': ubah port trunk (port 0) dari <code>dot1q</code> menjadi <code>access</code> VLAN 10.

'''Hasil''': Staff1 dan Tamu sama-sama tidak bisa internetan, tapi dengan alasan berbeda.

<pre>
Normal (dot1q): switch ══[tag 10][tag 20]══► CHR → vlan10 / vlan20 ✅
Salah (access 10): switch ───[polos, VLAN 10 saja]──► CHR → ether2 (tanpa IP) ❌
VLAN 20 → tidak dikirim sama sekali ❌
</pre>

* '''Staff1''': switch mengirim traffic VLAN 10 ke CHR '''tanpa tag'''. <code>vlan10</code> hanya menerima frame bertag 10, sehingga frame polos jatuh ke <code>ether2</code> yang tidak punya IP. ARP ke gateway tidak pernah terjawab.
* '''Tamu''': port 0 sekarang hanya anggota VLAN 10, sehingga frame VLAN 20 tidak pernah dikirim keluar. Tamu terkurung di dalam switch.

'''Pelajaran''': kedua ujung trunk harus '''sepakat'''. Kalau satu sisi mengirim bertag dan sisi lain menunggu polos (atau sebaliknya), link terlihat menyala (lampu hijau, interface Running), tapi traffic tidak tersambung. Sering terjadi saat mengganti switch atau saat ada yang "merapikan" konfigurasi.

== Kesalahan umum ==
{| class="wikitable"
! Gejala !! Penyebab !! Solusi
|-
| PC "DDD" setelah setting VLAN || Nomor port switch tidak cocok dengan kabel || Cek '''Show interface labels'''
|-
| PC dapat IP tapi tidak bisa internetan || IP gateway belum dipasang di VLAN interface || '''IP → Addresses''' di <code>vlanXX</code>
|-
| PC di VLAN baru "DDD" padahal router benar || VLAN belum didaftarkan di trunk switch || Tambahkan VLAN ke daftar trunk
|-
| Link menyala tapi semua VLAN putus || Trunk tidak sepakat (tagged vs untagged) || Samakan konfigurasi kedua ujung
|-
| PC dapat IP dari segmen yang salah || Port switch salah VLAN, atau unmanaged switch di trunk port || Periksa port dan perangkat yang tersambung
|-
| Comment tidak sesuai isi || Typo saat membuat objek || Perbaiki, karena comment adalah dokumentasi
|}

== Ringkasan ==
* VLAN memecah satu switch menjadi beberapa segmen Layer 2 terpisah.
* Tag 802.1Q (4 byte, berisi VLAN ID) hanya ada di trunk. PC selalu mengirim frame polos.
* Access = satu VLAN untagged. Trunk = banyak VLAN tagged.
* Router-on-a-stick: satu trunk, satu VLAN interface + gateway per VLAN.
* VLAN ditentukan port switch, bukan PC.
* Kedua ujung trunk harus sepakat.

Networking

2026-10-26T06:33:28Z

SanzSkuy:

= Networking =
* [[Model OSI]]
* [[Lapisan Transport (TCP dan UDP)]]
* [[Kelas Alamat IP]]
* [[Subnetting 1]]
* [[VLSM]]
* [[Magic Number Method & Subnetting Jaringan Besar]]
* [[Subnetting: Contoh Oktet ke-3 vs ke-4]]
* [[Private IP Address (RFC 1918)]]
* [[Ethernet & Layer 2 (Data Link)]]
* [[Media Koneksi Ethernet (Layer 1)]]
* [[Perangkat Jaringan: Hub, Switch, dan Router]]

= Mikrotik =
* [[Mikrotik 1: Install GNS3 Arch Linux]]
* [[Mikrotik 2: Kantor Mini]]
* [[Mikrotik 3: Bridge]]
* [[Mikrotik 4: VLAN]]

= Cisco =
* [[Cisco IOS]]
* [[Perintah Dasar Cisco IOS]]

== Cisco Lab ==
* [[Lab 0.1 - Basic Device Hardening]]

Mikrotik 3: Bridge

2026-10-25T05:17:00Z

SanzSkuy: Created page with ""''bridge''' adalah cara menggabungkan beberapa port router menjadi satu segmen jaringan. == Tujuan == * Paham apa itu bridge dan kenapa port router defaultnya berdiri sendiri. * Tahu kapan memakai bridge dan kapan memisahkan segmen. * Bisa membuktikan beda '''switching''' dan '''routing''' lewat <code>trace</code>. * Bisa melacak perangkat ke port fisik lewat '''Bridge → Hosts'''. == Konsep == === Port router berdiri sendiri === Di RouterOS, '''setiap port etherne..."

"''bridge''' adalah cara menggabungkan beberapa port router menjadi satu segmen jaringan.

== Tujuan ==
* Paham apa itu bridge dan kenapa port router defaultnya berdiri sendiri.
* Tahu kapan memakai bridge dan kapan memisahkan segmen.
* Bisa membuktikan beda '''switching''' dan '''routing''' lewat <code>trace</code>.
* Bisa melacak perangkat ke port fisik lewat '''Bridge → Hosts'''.

== Konsep ==

=== Port router berdiri sendiri ===
Di RouterOS, '''setiap port ethernet adalah interface terpisah'''. Tanpa bridge, <code>ether2</code> dan <code>ether3</code> adalah dua segmen yang sama sekali tidak tersambung, seperti dua switch tanpa kabel penghubung.

Konsekuensinya:
* Setiap port yang dipakai butuh '''subnet sendiri''' (seperti Part 2: <code>ether2</code> = <code>192.168.10.0/24</code>, <code>ether3</code> = <code>192.168.11.0/24</code>).
* Subnet yang sama '''tidak bisa''' dipasang di dua port (network tidak boleh tumpang tindih).
* Port tanpa IP dan bukan anggota bridge '''tidak melakukan apa-apa'''. Perangkat yang dicolok ke sana tidak mendapat apa pun.

{| class="wikitable"
! Perangkat !! Kondisi default port LAN
|-
| Router rumahan || Sudah menjadi satu switch dari pabrik
|-
| Router MikroTik fisik || Biasanya membawa '''defconf''': port LAN sudah dimasukkan ke <code>bridge</code>
|-
| CHR || Tidak ada defconf, setiap port berdiri sendiri
|}

Bridge dengan comment <code>defconf</code> di router MikroTik adalah bridge bawaan pabrik. Bridge lain biasanya dibuat oleh admin untuk memisahkan segmen.

=== Apa itu bridge ===
'''Bridge adalah switch versi software di dalam router.''' Port yang dimasukkan ke satu bridge menjadi '''satu segmen Layer 2''', seolah dicolok ke satu switch.

Konsep yang sama dipakai di tempat lain:
* <code>virbr0</code> (libvirt, [[Belajar MikroTik Part 1|Part 1]])
* <code>vmbr0</code> (Proxmox)

'''Dua aturan penting'''
# '''IP, DHCP server, dan konfigurasi Layer 3 lainnya dipasang di bridge''', bukan di port anggotanya. Port anggota hanya menjadi "colokan switch".
# Port anggota bridge mendapat flag '''S''' (slave). Flag '''RS''' = Running + Slave.

=== Bridge vs segmen terpisah ===
Analogi: bridge = satu ruangan besar, semua bisa langsung bicara. Segmen terpisah = banyak ruangan, komunikasi antar ruangan lewat resepsionis (router).

{| class="wikitable"
! !! Segmen terpisah (routed) !! Bridge (switched)
|-
| '''Konfigurasi''' || Subnet, pool, DHCP server, DHCP network per port || Satu set untuk semua port
|-
| '''Pindah colokan''' || IP ikut berubah || IP tetap
|-
| '''Discovery berbasis broadcast/multicast''' (printer, network discovery, AirPlay, Wake-on-LAN) || Tidak menyeberang subnet || Berjalan
|-
| '''Kinerja antar port''' || Di-route oleh CPU || Di perangkat fisik bisa memakai '''hardware offload''' switch chip (di CHR semuanya software)
|-
| '''Isolasi''' || Bisa diberi firewall antar segmen || Tidak ada isolasi
|-
| '''Dampak masalah''' (loop, broadcast storm, rogue DHCP) || Terbatas di satu segmen || Mengenai semua perangkat di bridge
|}

'''Kapan memakai yang mana'''
* Port LAN biasa untuk karyawan → '''bridge'''.
* Perlu memisahkan tamu, CCTV, atau server → '''segmen terpisah''' + firewall.

Di kantor biasanya '''kombinasi''': beberapa bridge, masing-masing berisi beberapa port, dan antar bridge di-route. Memisahkan segmen per port fisik itu kaku, sehingga solusi modernnya adalah '''VLAN''' ([[Belajar MikroTik Part 4|Part 4]]).

== Lab: menggabungkan ether2 + ether3 ==

=== Topologi ===
<pre>
[NAT]
│
ether1 (WAN)
│
[MikroTikCHR-1]
│ │ │
┌── bridge-lan ──┐ ether4
│ 192.168.10.1/24│ 192.168.20.1/24
ether2 ether3 │
│ │ [Switch3]
[Switch1] [Switch2] │
PC1 PC2 PC3 PC4 PC5 PC6
</pre>
* <code>ether2</code> + <code>ether3</code> digabung di <code>bridge-lan</code>, sehingga PC1–PC5 berada di satu subnet.
* <code>ether4</code> berdiri sendiri dengan subnet <code>192.168.20.0/24</code> sebagai '''pembanding''' segmen yang di-route.

=== 0. Backup dulu ===
Biasakan sebelum mengubah konfigurasi:
* GNS3: '''Edit → Manage snapshots → Create'''
* atau di terminal router:
<syntaxhighlight lang="text">
/export file=fase1-selesai
</syntaxhighlight>

=== 1. Hapus konfigurasi LAN2 lama ===
* '''IP → Addresses''': hapus <code>192.168.11.1/24</code>
* '''IP → DHCP Server → DHCP''': hapus server di <code>ether3</code>
* '''IP → DHCP Server → Networks''': hapus <code>192.168.11.0/24</code>
* '''IP → Pool''': hapus <code>pool-lan2</code>

=== 2–5. Buat bridge dan pindahkan konfigurasi ===
{| class="wikitable"
! # !! Winbox !! Isian !! CLI
|-
| 2 || '''Bridge → Bridge''' → New || Name <code>bridge-lan</code> || <code>/interface bridge add name=bridge-lan</code>
|-
| 3 || '''Bridge → Ports''' → New (dua kali) || <code>ether2</code> dan <code>ether3</code> ke <code>bridge-lan</code> || <code>/interface bridge port add bridge=bridge-lan interface=ether2</code> <code>/interface bridge port add bridge=bridge-lan interface=ether3</code>
|-
| 4 || '''IP → Addresses''' → edit <code>192.168.10.1/24</code> || Interface: <code>bridge-lan</code> || <code>/ip address set [find address="192.168.10.1/24"] interface=bridge-lan</code>
|-
| 5 || '''IP → DHCP Server → DHCP''' → edit server LAN || Interface: <code>bridge-lan</code> || <code>/ip dhcp-server set [find interface=ether2] interface=bridge-lan</code>
|}

Rule NAT tidak perlu diubah, karena tetap mencocokkan <code>out-interface=ether1</code>.

=== 6. Perbarui IP di semua PC ===
<syntaxhighlight lang="text">
ip dhcp -x
ip dhcp
show ip
</syntaxhighlight>

=== Pembanding: segmen ether4 ===
Untuk Switch3 + PC6, <code>ether4</code> dikonfigurasi seperti LAN di Part 2: IP <code>192.168.20.1/24</code>, pool, DHCP network (gateway & DNS <code>192.168.20.1</code>), dan DHCP server sendiri.

== Verifikasi ==
* PC1–PC5 mendapat IP <code>192.168.10.x</code> dari pool yang sama dengan gateway <code>192.168.10.1</code>.
* '''Interfaces''': <code>ether2</code> dan <code>ether3</code> berflag '''RS'''.
* '''Bridge → Hosts''': daftar MAC semua PC beserta port tempat mereka terhubung.
* <code>ping 8.8.8.8</code> dari PC berhasil.

== Membaca <code>trace</code> ==
<syntaxhighlight lang="text">
trace <IP tujuan> # di VPCS
/tool traceroute 8.8.8.8 # di router
</syntaxhighlight>

Setiap baris adalah satu '''hop''', yaitu perangkat Layer 3 (router) yang dilewati. Trace mengirim paket dengan '''TTL''' kecil (mulai dari 1). Setiap router mengurangi TTL satu, dan router tempat TTL habis membalas, sehingga trace bisa menyusun daftar router di sepanjang jalur.

* '''Switch dan bridge tidak mengurangi TTL''', sehingga tidak pernah muncul di hasil trace.
* Baris terakhir dengan <code>Destination port unreachable</code> itu '''normal'''. VPCS mengirim UDP ke port yang tidak dipakai, dan balasan "port tidak ada" menandakan paket sudah sampai di tujuan.

== Latihan dan pembahasan ==

=== Soal 1: bandingkan trace dengan Fase 1 ===
'''Soal''': trace dari PC1/PC4 ke PC lain di bridge, bandingkan dengan Fase 1 (Part 2) dan dengan PC6.

'''Hasil'''
<pre>
PC6 → PC1 (192.168.10.200):
1 192.168.20.1 ← router, beda subnet → di-route
2 192.168.10.200 ← tujuan

PC4 → PC1 (192.168.10.200):
1 192.168.10.200 ← langsung sampai, satu bridge → di-switch
</pre>

'''Pembahasan'''
* Di Fase 1, PC1 dan PC4 berada di subnet berbeda, sehingga ada hop tambahan lewat router.
* Sekarang PC4 dan PC1 berada di '''satu bridge = satu segmen Layer 2'''. PC4 meng-ARP PC1 secara langsung, dan CHR hanya meneruskan frame seperti switch.
* Paket '''tetap melewati CHR secara fisik''', tapi tidak muncul sebagai hop. Router yang sama bekerja sebagai '''switch''' untuk traffic di dalam bridge dan sebagai '''router''' untuk traffic antar subnet (seperti ke PC6).

=== Soal 2: detektif port ===
'''Soal''': hanya lewat '''Bridge → Hosts''', tentukan PC5 terhubung di port mana.

'''Pembahasan''': cocokkan MAC dari <code>show ip</code> di PC5 dengan tabel Hosts → '''<code>ether3</code>'''. Di kantor, ini cara tercepat mencari "PC ini dicolok di port mana" tanpa menyusuri kabel.

=== Soal 3: disable port anggota bridge ===
'''Soal''': disable <code>ether3</code> di '''Bridge → Ports'''. Apakah PC4 masih bisa ping PC5? Ping PC1?

'''Hasil''': PC4 → PC5 '''bisa''', PC4 → PC1 '''tidak bisa'''.

'''Pembahasan'''
* '''PC4 → PC5''': keduanya terhubung ke Switch2. Switch2 meneruskan frame di antara mereka sendiri tanpa butuh router atau bridge.
* '''PC4 → PC1''': <code>ether3</code> adalah satu-satunya penghubung Switch2 ke bridge. Setelah port itu mati, Switch2 menjadi "pulau" terpisah.
* '''Kenapa router tidak menolong?''' PC4 menganggap PC1 '''tetangga''' (sama-sama <code>192.168.10.x</code>), sehingga PC4 tidak pernah memakai gateway untuk menuju PC1. Ia hanya meng-ARP PC1, dan ARP itu tidak sampai ke mana pun. '''Di dalam satu subnet, kalau jalur Layer 2 putus, router tidak bisa menjadi jalur alternatif.'''
* Gateway (<code>192.168.10.1</code>) dan internet juga tidak terjangkau dari PC4 dan PC5.

'''Pelajaran di kantor''': gejala '''"satu ruangan tidak bisa apa-apa, tapi PC di ruangan itu masih bisa saling berbagi file"''' hampir pasti masalah '''uplink''' switch ruangan tersebut: kabel uplink, port di router/switch inti, atau port yang ter-disable.

Jangan lupa enable kembali <code>ether3</code>.

== Masalah yang ditemui ==

=== Gateway DHCP berisi alamat network ===
'''Gejala''': DHCP Networks berisi gateway <code>192.168.10.0</code> dan DNS kosong setelah menjalankan '''DHCP Setup'''.

'''Penyebab''': isian gateway di wizard salah. <code>.0</code> adalah alamat network, bukan alamat perangkat.

'''Solusi''': '''IP → DHCP Server → Networks''' → gateway & DNS <code>192.168.10.1</code>. Selalu periksa hasil wizard.

=== Static lease hilang setelah DHCP Setup ===
'''Gejala''': lease PC1 kembali bertanda '''D''' (dynamic), nama server menjadi <code>server1</code> dan pool menjadi <code>pool1</code>.

'''Penyebab''': lease terikat ke DHCP server. Server lama diganti oleh wizard, sehingga static lease ikut hilang.

'''Solusi''': buat ulang static lease. '''Pelajaran''': wizard bisa menimpa konfigurasi lama tanpa peringatan, jadi backup sebelum menjalankannya.

=== IP WAN berubah ===
'''Gejala''': IP <code>ether1</code> berubah dari <code>192.168.122.212</code> menjadi <code>192.168.122.61</code>.

'''Penyebab''': CHR/lab di-restart dan mendapat lease baru dari dnsmasq <code>virbr0</code>. Flag '''D''' pada alamat WAN memang akan selalu ada karena dibuat oleh DHCP client.

'''Dampak''': NAT tetap berjalan karena masquerade otomatis memakai IP yang sedang menempel. Winbox harus connect ulang ke IP baru. Ini contoh nyata kenapa masquerade cocok untuk WAN dinamis.

=== VPCS hanya menampilkan "DDD" ===
'''Gejala'''
<pre>
PC1> ip dhcp
DDD
Can't find dhcp server
</pre>

'''Arti''': VPCS mencetak satu huruf per langkah DORA. '''D''' = Discover terkirim. "DDD" berarti tiga Discover terkirim '''tanpa Offer''' yang kembali.

'''Langkah diagnosis'''
# Periksa konfigurasi DHCP Networks (gateway & DNS).
# '''Log''' router: cari pesan dari <code>dhcp</code>.
# '''IP → DHCP Server → DHCP''': pastikan server tidak berflag '''X''' (disabled) atau '''I''' (invalid).
# '''Tools → Torch''' di <code>bridge-lan</code>: kalau muncul traffic <code>0.0.0.0 → 255.255.255.255</code> (port 68 → 67), Discover sampai di router dan masalahnya di konfigurasi. Kalau kosong, masalahnya di jalur kabel/bridge.
# '''Bridge → Hosts''': apakah MAC PC terlihat.
# Di VPCS: <code>ip dhcp -d</code> untuk melihat detail paket.

'''Penyebab di lab ini''': GNS3 "nyangkut" (koneksi virtual antar node tidak terbentuk ulang dengan benar setelah topologi diubah). Selesai setelah GNS3 di-restart.

'''Urutan perbaikan kalau GNS3 berperilaku aneh''' (setelah konfigurasi dipastikan benar):
# Stop/start node yang bermasalah, termasuk switch.
# Hapus dan sambungkan ulang kabel.
# Restart GNS3.

== Sisipan: bridge di dunia virtualisasi (Proxmox) ==
Server Proxmox di LAN bisa menghasilkan banyak IP dari VM-VM-nya. Cara VM terlihat di jaringan tergantung modelnya.

{| class="wikitable"
! Model !! Cara kerja !! Kelebihan !! Kekurangan
|-
| '''Bridged''' (default, <code>vmbr0</code>) || Bridge menyatukan NIC fisik dan NIC virtual VM. Setiap VM punya MAC sendiri dan terlihat seperti PC terpisah. || VM dapat IP dari DHCP router, bisa diakses langsung dari LAN || Setiap VM memakan IP subnet kantor
|-
| '''NAT''' || Host menjadi router mini dan me-masquerade VM (sama seperti <code>virbr0</code>) || Hemat IP, VM terisolasi || VM tidak bisa diakses langsung, perlu port forwarding
|-
| '''Subnet/VLAN khusus''' || VM di segmen sendiri, di-route oleh router || Rapi, bisa diberi firewall || Butuh VLAN (Part 4)
|}

'''Manajemen IP'''
* '''Rencanakan pembagian IP''', contoh untuk <code>/24</code>:
{| class="wikitable"
! Range !! Untuk
|-
| <code>.1</code> || Gateway
|-
| <code>.2–.19</code> || Perangkat jaringan (switch, AP)
|-
| <code>.20–.79</code> || Server & VM (statis)
|-
| <code>.80–.99</code> || Printer, CCTV
|-
| <code>.100–.250</code> || Pool DHCP
|}
* '''Server/VM memakai IP tetap''': manual di dalam VM atau static lease. MAC VM Proxmox tersimpan permanen di konfigurasi VM, sehingga static lease bekerja baik.
* '''Hati-hati saat clone''': clone biasanya mendapat MAC baru, sehingga static lease tidak ikut. IP statis yang di-hardcode di template akan ikut ter-clone dan menyebabkan IP conflict.
* '''Catat semuanya (IPAM)''': spreadsheet, atau tools seperti '''NetBox''' / '''phpIPAM'''.
* '''Pantau ukuran subnet''': <code>/24</code> hanya 254 host. Kolom '''Available''' di menu Pool menunjukkan sisa IP.

Di host Proxmox, cek <code>/etc/network/interfaces</code>:
* <code>vmbr0</code> dengan <code>bridge-ports eno1</code> → bridged.
* <code>bridge-vlan-aware yes</code> → VM dipisah dengan VLAN.

== Ringkasan ==
* Port RouterOS defaultnya berdiri sendiri, dan bridge menggabungkannya menjadi satu segmen Layer 2.
* Konfigurasi Layer 3 (IP, DHCP) dipasang di '''bridge''', bukan di port anggota.
* Di dalam bridge = '''switching''' (tidak ada hop). Antar subnet = '''routing''' (ada hop lewat gateway).
* Dalam satu subnet, jalur Layer 2 yang putus tidak bisa ditolong router.
* Wizard praktis, tapi periksa hasilnya dan backup sebelum menjalankannya.

Networking

2026-10-25T05:16:52Z

SanzSkuy:

= Networking =
* [[Model OSI]]
* [[Lapisan Transport (TCP dan UDP)]]
* [[Kelas Alamat IP]]
* [[Subnetting 1]]
* [[VLSM]]
* [[Magic Number Method & Subnetting Jaringan Besar]]
* [[Subnetting: Contoh Oktet ke-3 vs ke-4]]
* [[Private IP Address (RFC 1918)]]
* [[Ethernet & Layer 2 (Data Link)]]
* [[Media Koneksi Ethernet (Layer 1)]]
* [[Perangkat Jaringan: Hub, Switch, dan Router]]

= Mikrotik =
* [[Mikrotik 1: Install GNS3 Arch Linux]]
* [[Mikrotik 2: Kantor Mini]]
* [[Mikrotik 3: Bridge]]

= Cisco =
* [[Cisco IOS]]
* [[Perintah Dasar Cisco IOS]]

== Cisco Lab ==
* [[Lab 0.1 - Basic Device Hardening]]

Mikrotik 2: Kantor Mini

2026-10-23T07:38:21Z

SanzSkuy:

Fase 1 dari roadmap: membangun '''"kantor mini"''', yaitu satu router MikroTik sebagai gateway, beberapa PC yang mendapat IP otomatis, dan semuanya bisa internetan. Konfigurasi dilakukan lewat '''Winbox 4''', dengan padanan CLI di setiap langkah.

== Tujuan ==
* Paham peran IP address, gateway, DHCP, DNS, dan NAT di jaringan kantor.
* Paham beda '''switching''' (Layer 2) dan '''routing''' (Layer 3).
* Bisa membaca kondisi router: siapa yang tersambung, dapat IP apa, lewat mana.

== Topologi ==
<pre>
[NAT]
│
ether1 (WAN, DHCP client)
192.168.122.212/24
│
[MikroTikCHR-1]
ether2 / \ ether3
192.168.10.1/24 192.168.11.1/24
│ │
[Switch1] [Switch2]
/ | \ / \
PC1 PC2 PC3 PC4 PC5
</pre>

* '''NAT node''' dari [[Belajar MikroTik Part 1|Part 1]] tetap di <code>ether1</code>.
* '''Ethernet switch''' dan '''VPCS''' adalah perangkat bawaan GNS3 (kategori Switches dan End devices).

'''Pengingat''': setelah reboot host, jalankan ulang aturan <code>DOCKER-USER</code> dari Part 1, kalau tidak traffic lab tidak bisa keluar ke internet.

== Konsep dasar ==

=== IP address, subnet, dan alamat spesial ===
<code>/24</code> berarti 24 bit pertama adalah bagian '''network''', 8 bit terakhir bagian '''host'''.

<pre>
192.168.10. | 00000000 → .0 semua bit host 0 = alamat network
192.168.10. | 00000001 → .1 host pertama
192.168.10. | 11111110 → .254 host terakhir
192.168.10. | 11111111 → .255 semua bit host 1 = broadcast
</pre>

{| class="wikitable"
! Alamat !! Fungsi !! Bisa dipakai perangkat?
|-
| <code>192.168.10.0</code> || Network address (identitas subnet) || Tidak
|-
| <code>192.168.10.1</code> – <code>.254</code> || Alamat host (254 host) || Ya
|-
| <code>192.168.10.255</code> || Broadcast (ke semua di subnet) || Tidak
|}

'''Kapan menulis <code>.1/24</code> dan kapan <code>.0/24</code>?'''
* '''IP → Addresses''' menjawab "IP gua apa?" → alamat host, misalnya <code>192.168.10.1/24</code>. Kolom Network dihitung otomatis.
* '''Route, DHCP Network, firewall''' menjawab "network yang mana?" → alamat network, misalnya <code>192.168.10.0/24</code>.

'''Range IP privat''' (tidak dikenal di internet): <code>10.0.0.0/8</code>, <code>172.16.0.0/12</code> (172.16–172.31), <code>192.168.0.0/16</code>.

=== Gateway ===
Gateway adalah "pintu keluar" PC. Tujuan di luar subnet sendiri dikirim ke gateway.

'''Aturan emas''': gateway '''harus berada di subnet yang sama''' dengan PC. Biasanya berupa IP router di interface tersebut. Gateway di <code>.1</code> hanya kebiasaan, bukan aturan.

=== ARP ===
Di dalam satu segmen, frame Ethernet dikirim berdasarkan '''MAC address''', bukan IP. '''ARP''' menerjemahkan '''IP → MAC''' di dalam satu segmen.

# '''Request (broadcast)''': "Siapa yang punya <code>192.168.10.1</code>? Kasih tahu <code>192.168.10.100</code>."
# '''Reply (unicast)''': "Itu gua, MAC gua <code>0C:B3:C6:FB:00:01</code>."
# Hasilnya disimpan di '''tabel ARP''' (cache) dan kedaluwarsa setelah beberapa waktu.

'''Poin penting''': saat PC ping <code>8.8.8.8</code>, yang di-ARP adalah '''gateway''', bukan <code>8.8.8.8</code>. Di setiap lompatan, '''IP tujuan tetap sama''', tapi '''MAC tujuan berganti'''. Inilah beda Layer 2 (antar tetangga) dan Layer 3 (ujung ke ujung).

Switch juga punya tabel MAC, tapi isinya "MAC ini ada di port mana". Switch tidak peduli IP.

=== DHCP ===
PC yang baru tersambung belum punya IP, gateway, maupun DNS. DHCP membagikannya secara otomatis lewat proses '''DORA''':
# '''Discover''': PC broadcast "ada DHCP server?"
# '''Offer''': server menawarkan IP + gateway + DNS
# '''Request''': PC menerima tawaran
# '''Ack''': server mengonfirmasi dan mencatat lease

Di RouterOS, DHCP dipecah menjadi tiga bagian:
{| class="wikitable"
! Bagian !! Menjawab !! Alasan dipisah
|-
| '''Pool''' || IP mana yang boleh dibagikan? || Pool dipakai ulang oleh fitur lain (VPN, PPPoE, Hotspot)
|-
| '''Network''' || Info apa yang diberikan (gateway, DNS)? || Satu server bisa melayani banyak subnet (lewat relay)
|-
| '''Server''' || Siapa yang melayani, di interface mana? || Mengikat semuanya ke satu segmen
|}

* '''Lease time''' (default 30 menit): lama IP "disewakan". PC memperpanjang sebelum habis, dan IP kembali ke pool kalau PC pergi.
* '''Kenapa pool mulai dari <code>.100</code>''': <code>.2–.99</code> disisakan untuk perangkat ber-IP tetap (server, printer, access point, CCTV).

'''Di mana DHCP server diletakkan?''' Broadcast DHCP '''tidak menyeberang router''', jadi DHCP server harus berada di segmen yang sama dengan client, atau memakai '''DHCP relay''' yang meneruskan permintaan ke server di network lain.

{| class="wikitable"
! Skenario !! Lokasi DHCP server
|-
| Rumah || Modem/router ISP
|-
| Kantor kecil-menengah || Router MikroTik, satu server per segmen/VLAN
|-
| Kantor besar || Server khusus (Windows Server, Kea, dnsmasq) + DHCP relay di router
|}

Di lab ini CHR berperan ganda: '''client''' di sisi WAN (dapat IP dari dnsmasq libvirt) dan '''server''' di sisi LAN.

'''Satu segmen = satu DHCP server.''' Dua server di segmen yang sama membuat PC bisa mendapat konfigurasi yang salah. Kasus klasiknya '''rogue DHCP''': router Wi-Fi rumahan yang dicolok ke jaringan kantor.

=== DNS ===
PC diarahkan ke router (<code>192.168.10.1</code>) sebagai DNS server. Router meneruskan pertanyaan ke '''Dynamic Servers''' (<code>192.168.122.1</code>, didapat dari DHCP di WAN) dan menyimpan jawabannya di cache.

* '''Allow Remote Requests''' harus dicentang, karena defaultnya DNS router hanya untuk dirinya sendiri.
* Keuntungan lewat router: cache, kontrol terpusat (nama lokal, blokir domain), dan ganti DNS upstream cukup di satu tempat.

=== NAT (masquerade) ===
IP privat tidak bisa dibalas oleh internet. '''Masquerade''' mengganti '''IP sumber''' paket yang keluar lewat WAN menjadi IP router, lalu mencatat pemetaannya di '''connection tracking''' supaya balasan bisa dikembalikan ke PC yang benar.

* '''Chain <code>srcnat</code>''': yang diubah alamat sumber, diproses setelah keputusan routing.
* '''Out. Interface <code>ether1</code>''': hanya traffic ke arah WAN yang di-NAT.
* '''<code>masquerade</code> vs <code>src-nat</code>''': masquerade otomatis memakai IP yang sedang menempel di interface, cocok untuk IP WAN dinamis. <code>src-nat</code> dipakai kalau IP publik statis.

'''Kenapa NAT ada di menu Firewall?''' Firewall RouterOS adalah mesin pemroses paket dengan beberapa tabel (Filter, NAT, Mangle, Raw), persis seperti <code>iptables</code> di Linux:
<syntaxhighlight lang="bash">
# padanan rule masquerade di Linux
iptables -t nat -A POSTROUTING -o ether1 -j MASQUERADE
</syntaxhighlight>

'''Fakta menarik''': <code>virbr0</code> + dnsmasq dari libvirt (Part 1) melakukan hal yang sama persis dengan router di lab ini: IP gateway, DHCP, DNS, dan masquerade. Lab ini juga '''double NAT''': paket di-masquerade CHR, lalu di-NAT lagi oleh <code>virbr0</code>. Banyak kantor sungguhan juga begini (router kantor di belakang modem ISP).

=== Perjalanan satu ping ===
<pre>
PC1 (192.168.10.100) ping 8.8.8.8
│ "bukan tetangga → kirim ke gateway" (ARP gateway → dapat MAC router)
▼
CHR ether2 ── routing: 0.0.0.0/0 via 192.168.122.1 ── keluar ether1
│ srcnat masquerade: src 192.168.10.100 → 192.168.122.212
▼
virbr0 (host) ── masquerade lagi: src → IP host
▼
Internet ── balasan kembali, setiap NAT membalik alamatnya ── PC1 ✅
</pre>

== Konfigurasi LAN pertama ==

=== Konek Winbox ===
Isi '''Connect To''' dengan IP WAN CHR (contoh <code>192.168.122.212</code>), login <code>admin</code>. Konek lewat MAC di tab '''Neighbors''' belum tentu berhasil melalui <code>virbr0</code>, jadi pakai IP.

=== Langkah-langkah ===
{| class="wikitable"
! # !! Winbox !! Isian !! CLI
|-
| 1 || '''IP → Addresses''' → New || Address <code>192.168.10.1/24</code>, Interface <code>ether2</code>, Comment <code>LAN</code> || <code>/ip address add address=192.168.10.1/24 interface=ether2 comment=LAN</code>
|-
| 2 || '''IP → Pool''' → New || Name <code>pool-lan</code>, Addresses <code>192.168.10.100-192.168.10.200</code> || <code>/ip pool add name=pool-lan ranges=192.168.10.100-192.168.10.200</code>
|-
| 3 || '''IP → DHCP Server''' → tab '''Networks''' → New || Address <code>192.168.10.0/24</code>, Gateway <code>192.168.10.1</code>, DNS <code>192.168.10.1</code> || <code>/ip dhcp-server network add address=192.168.10.0/24 gateway=192.168.10.1 dns-server=192.168.10.1</code>
|-
| 4 || '''IP → DHCP Server''' → tab '''DHCP''' → New || Name <code>dhcp-lan</code>, Interface <code>ether2</code>, Address Pool <code>pool-lan</code> || <code>/ip dhcp-server add name=dhcp-lan interface=ether2 address-pool=pool-lan disabled=no</code>
|-
| 5 || '''IP → DNS''' || Centang '''Allow Remote Requests''' || <code>/ip dns set allow-remote-requests=yes</code>
|-
| 6 || '''IP → Firewall''' → tab '''NAT''' → New || General: Chain <code>srcnat</code>, Out. Interface <code>ether1</code>; Action: <code>masquerade</code> || <code>/ip firewall nat add chain=srcnat out-interface=ether1 action=masquerade comment="NAT ke internet"</code>
|}

'''Catatan langkah 1''': entri <code>192.168.122.x</code> di <code>ether1</code> dengan flag '''D''' (Dynamic) adalah IP WAN dari DHCP client. Jangan dihapus. Router memang punya '''satu IP di setiap network''' yang ia sambungkan, dan network di interface berbeda '''tidak boleh tumpang tindih'''.

'''Peringatan keamanan''': CHR ini belum punya firewall filter, dan <code>allow-remote-requests=yes</code> membuat DNS router bisa ditanya dari sisi WAN. Aman di lab, tapi di router sungguhan harus diblok (Fase 3).

=== Trik Winbox ===
* Tombol '''DHCP Setup''' mengerjakan langkah 2–4 sekaligus. Pakai setelah paham cara manualnya.
* '''Terminal''' tersedia di dalam Winbox. Jalankan <code>/ip firewall nat export</code> untuk melihat padanan CLI dari apa yang diklik di GUI.
* '''Safe Mode''': kalau koneksi putus karena salah setting, perubahan otomatis dibatalkan. Biasakan menyalakannya.

== Verifikasi ==
Di VPCS:
<syntaxhighlight lang="text">
ip dhcp
show ip
ping 192.168.10.1
ping 8.8.8.8
ping google.com
trace 8.8.8.8
show arp
</syntaxhighlight>
<code>trace</code> menampilkan hop lewat <code>192.168.10.1</code> lalu <code>192.168.122.1</code>, jadi double NAT terlihat langsung.

=== Melihat perangkat yang tersambung ===
{| class="wikitable"
! Menu !! Menampilkan !! Keterbatasan
|-
| '''IP → DHCP Server → Leases''' || IP, MAC, hostname, status (<code>bound</code>) || Hanya perangkat yang memakai DHCP
|-
| '''IP → ARP''' || Perangkat yang baru-baru ini berkomunikasi, termasuk IP statis || Perangkat yang diam bisa tidak muncul
|-
| '''Bridge → Hosts''' || MAC per port fisik || Hanya untuk port anggota bridge
|-
| '''IP → Neighbors''' || Perangkat jaringan (MNDP/LLDP/CDP) || PC biasa umumnya tidak muncul
|-
| '''Tools → IP Scan''' || Scan aktif satu range || Harus dijalankan manual
|}

Kombinasi di kantor: '''Leases''' (perangkat siapa), '''ARP''' (siapa yang aktif), '''Bridge Hosts''' (colok di port mana).

Melihat paket ARP secara langsung: klik kanan kabel di GNS3 → '''Start capture''', lalu di PC jalankan <code>clear arp</code> dan <code>ping 192.168.10.1</code>.

== LAN kedua dan routing antar subnet ==

=== Konfigurasi ===
{| class="wikitable"
! Bagian !! Isian
|-
| IP → Addresses || <code>192.168.11.1/24</code> di <code>ether3</code> (beri comment, misalnya <code>LAN2</code>)
|-
| IP → Pool || <code>pool-lan2</code>: <code>192.168.11.100-192.168.11.200</code>
|-
| DHCP → Networks || <code>192.168.11.0/24</code>, gateway & DNS <code>192.168.11.1</code>
|-
| DHCP → DHCP || Server baru di <code>ether3</code> dengan <code>pool-lan2</code>
|-
| NAT || '''Tidak perlu diubah''': rule mencocokkan <code>out-interface=ether1</code>, jadi semua subnet yang keluar ke WAN otomatis di-masquerade
|}

=== Kenapa PC1 bisa ping PC4? ===
# PC1 melihat <code>192.168.11.x</code> bukan tetangga → kirim ke gateway <code>192.168.10.1</code>.
# Router sudah mengenal kedua network sebagai '''connected route''' (lihat '''IP → Routes'''):
<pre>
DAC 192.168.10.0/24 → ether2
DAC 192.168.11.0/24 → ether3
DAd 0.0.0.0/0 → 192.168.122.1 (dari DHCP client)
</pre>
:<code>D</code> = dynamic, <code>A</code> = active, <code>C</code> = connected.
# Router meng-ARP PC4 di sisi <code>ether3</code> lalu meneruskan paket.
# '''Tidak kena NAT''', karena traffic keluar lewat <code>ether3</code>, bukan <code>ether1</code>. PC4 melihat IP asli PC1.
# '''Tidak ada yang memblokir''', karena belum ada firewall filter.

=== Switching vs routing ===
{| class="wikitable"
! Tes !! Hasil <code>trace</code> !! Yang bekerja
|-
| PC1 → PC2 (satu switch) || Langsung sampai || '''Switch''' (Layer 2). Router tidak terlibat.
|-
| PC1 → PC4 (beda subnet) || Satu hop lewat <code>192.168.10.1</code> || '''Router''' (Layer 3)
|}

'''Implikasi di kantor''': memisahkan subnet '''tidak sama dengan isolasi'''. Secara default router menyambungkan semua subnet. Untuk memisahkan misalnya Wi-Fi tamu atau CCTV dari jaringan karyawan, dibutuhkan '''firewall filter di chain <code>forward</code>''' (Fase 3).

== Kesalahan umum ==
{| class="wikitable"
! Gejala !! Penyebab !! Solusi
|-
| PC dapat IP tapi tidak bisa internetan setelah ganti subnet || Gateway/DNS di DHCP Network masih memakai alamat subnet lama. PC tidak bisa meng-ARP gateway yang bukan tetangganya. || Gateway & DNS = IP router di subnet baru
|-
| Router punya dua IP di satu interface setelah ganti subnet || Menambah entri baru tanpa menghapus yang lama || Edit entri yang ada (double-click)
|-
| PC masih memakai IP lama || Lease lama belum diperbarui || Jalankan <code>ip dhcp</code> lagi di VPCS
|-
| Satu segmen mendadak dapat gateway aneh || Rogue DHCP (dua DHCP server di satu segmen) || Cari dan cabut DHCP server liar
|-
| Router bingung meneruskan paket || Dua interface memakai subnet yang tumpang tindih || Pakai subnet berbeda di setiap interface
|-
| <code>failure: dhcp-client on that interface already exists</code> || Appliance CHR sudah membawa DHCP client di <code>ether1</code> || Normal, abaikan
|-
| Parameter ditolak || <code>disable=no</code> || Yang benar <code>disabled=no</code>
|-
| Static lease sudah diubah tapi IP perangkat tetap || DHCP menunggu client bertanya (renew) || <code>ip dhcp -x</code> lalu <code>ip dhcp</code>, atau restart perangkat
|-
| Koneksi dua PC putus-nyambung acak || IP conflict (static lease ke IP yang sedang dipakai) || Taruh static lease di luar pool, cek Leases/ARP dulu
|-
| Router bisa internetan, semua PC tidak || Rule NAT hilang/disabled/<code>out-interface</code> salah || Cek '''IP → Firewall → NAT'''
|}

== Static lease ==
'''Static lease''' adalah reservasi IP di DHCP server berdasarkan '''MAC address'''. Setiap kali perangkat dengan MAC tersebut meminta IP, DHCP selalu memberikan IP yang sama.

'''Kenapa tidak set IP manual di perangkat saja?'''
* '''Terpusat''': semua IP diatur dari router. Ganti IP printer cukup dari Winbox.
* '''Gateway & DNS tetap ikut DHCP''': kalau gateway berubah, perangkat ikut berubah otomatis.
* Dipakai untuk printer, server, CCTV/NVR, access point, dan target '''port forwarding''' (Fase 3).

=== Contoh: mengunci IP PC4 ===
# '''IP → DHCP Server → tab Leases'''.
# Cari baris PC4 (cocokkan MAC dengan hasil <code>show ip</code> di VPCS). Ada flag '''D''' (dynamic).
# Pilih baris → '''Make Static'''. Flag '''D''' hilang.
# Untuk mengganti ke IP lain, double-click lease lalu ubah kolom '''Address'''.

<syntaxhighlight lang="text">
/ip dhcp-server lease make-static [find address=192.168.11.10x]
</syntaxhighlight>

=== Perubahan tidak langsung berlaku ===
Setelah static lease diubah, PC masih memakai IP lama. DHCP bersifat '''"client yang bertanya"''': router tidak bisa memaksa PC berganti IP. PC baru meminta lagi ketika:
* lease hampir habis (biasanya mulai memperpanjang di '''setengah lease time'''),
* kabel dicabut-colok atau perangkat restart,
* dipaksa manual.

<syntaxhighlight lang="text">
ip dhcp -x # release lease lama
ip dhcp # minta lease baru
show ip
</syntaxhighlight>

Tombol '''Send Reconfigure''' di Winbox hanya bekerja kalau client mendukung fitur tersebut. Kebanyakan perangkat (termasuk VPCS) tidak, jadi cara paling pasti tetap dari sisi client.

'''Di kantor''': setelah mengganti IP printer lewat static lease, printer tidak langsung pindah. Tunggu renew, atau restart perangkatnya.

== Latihan dan pembahasan ==

=== Soal 1: pindah subnet ===
'''Soal''': ubah LAN pertama menjadi <code>10.10.10.0/24</code> (gateway <code>.1</code>, pool <code>.50–.99</code>).

'''Pembahasan''': ada empat isian yang ikut berubah.
{| class="wikitable"
! Tempat !! Sebelum !! Sesudah
|-
| IP → Addresses || <code>192.168.10.1/24</code> || <code>10.10.10.1/24</code>
|-
| DHCP Network (address) || <code>192.168.10.0/24</code> || <code>10.10.10.0/24</code>
|-
| DHCP Network (gateway & DNS) || <code>192.168.10.1</code> || <code>10.10.10.1</code>
|-
| Pool || <code>192.168.10.100–200</code> || <code>10.10.10.50–99</code>
|}
* '''Rule NAT tidak perlu diubah''', karena mencocokkan <code>out-interface=ether1</code>, bukan alamat LAN.
* '''Jebakan''': lupa mengganti gateway di DHCP Network. PC mendapat <code>10.10.10.x</code> dengan gateway <code>192.168.10.1</code>, yang bukan tetangganya. PC tidak bisa meng-ARP gateway tersebut, dan router juga sudah tidak memilikinya. Hasilnya: dapat IP tapi tidak bisa internetan. Ini kesalahan yang sering terjadi saat migrasi subnet di kantor.

=== Soal 2: static lease ===
'''Soal''': buat PC1 selalu mendapat IP tetap, sementara PC lain tetap acak dari pool.

'''Pengerjaan''': Make Static pada lease PC1, ubah Address ke IP target (contoh: <code>192.168.10.253</code>), lalu di PC1 jalankan <code>ip dhcp -x</code> dan <code>ip dhcp</code>.

'''Pertanyaan 1: kenapa static lease sebaiknya di luar pool?'''
* Pool adalah wilayah DHCP dynamic. IP di luar pool tidak akan pernah dibagikan ke perangkat lain, jadi '''tidak mungkin bentrok'''.
* Mudah dibaca: <code>.2–.99</code> = perangkat penting, <code>.100+</code> = perangkat biasa.
* Aman saat pool diperbesar atau diperkecil.
* Konvensi umum: IP statis di range bawah (<code>.2–.99</code>).

'''Pertanyaan 2: kenapa PC1 tidak langsung berganti IP?'''
Lihat [[#Perubahan tidak langsung berlaku|Perubahan tidak langsung berlaku]].

'''Pertanyaan 3: static lease ke IP di dalam pool yang sedang dipakai PC lain?'''
Kemungkinan urutannya:
# Static lease <code>.150</code> dibuat untuk PC1, sementara PC2 masih memakai <code>.150</code> karena belum renew.
# Kalau PC1 renew dan mendapat <code>.150</code>, dua PC memakai IP yang sama: '''IP conflict'''.
# Keduanya menjawab ARP untuk <code>.150</code>. Tabel ARP router berganti-ganti MAC, sehingga koneksi kedua PC '''putus-nyambung acak'''.
# Saat PC2 renew, server menolak (IP sudah direservasi untuk MAC lain), dan PC2 mendapat IP baru dari pool. PC2 tidak harus di-release manual; <code>ip dhcp -x</code> hanya mempercepat.

Catatan: perilaku detail di langkah 2 bisa berbeda antar implementasi DHCP. Buktikan sendiri di lab sambil memantau '''Leases''' dan '''IP → ARP'''.

'''Pelajaran''': sebelum memasang static lease, pastikan IP-nya kosong (cek Leases dan ARP), atau taruh di luar pool.

=== Soal 3: LAN kedua ===
Lihat [[#LAN kedua dan routing antar subnet|LAN kedua dan routing antar subnet]].

=== Soal 4: NAT dimatikan ===
'''Soal''': disable rule NAT, lalu tes <code>/ping 8.8.8.8</code> dari router dan dari PC1.

<syntaxhighlight lang="text">
/ip firewall nat disable 0
/ping 8.8.8.8 count=4 # dari router
# ping 8.8.8.8 dari VPCS PC1
/ip firewall nat enable 0 # jangan lupa dinyalakan lagi
</syntaxhighlight>

'''Hasil''': ping dari router '''berhasil''', ping dari PC1 '''timeout'''.

'''Pembahasan''': paket dari keduanya keluar lewat kabel yang sama (<code>ether1</code>). Yang membedakan adalah '''IP sumber'''.
<pre>
Router → 8.8.8.8 src 192.168.122.212 → dikenal virbr0 ✅
PC1 → 8.8.8.8 src 192.168.10.200 → "ini siapa? baliknya lewat mana?" ❌
</pre>
* '''Router''' membuat paket sendiri dengan IP sumber interface keluarnya, <code>192.168.122.212</code>. IP itu ada di subnet <code>virbr0</code>, sehingga host tahu cara membalas, dan masquerade libvirt (untuk <code>192.168.122.0/24</code>) meneruskannya ke internet. Traffic yang dibuat router sendiri '''tidak membutuhkan''' rule masquerade di router.
* '''PC1''': tanpa NAT, IP sumber tetap <code>192.168.10.x</code>. Host tidak punya route ke <code>192.168.10.0/24</code>, dan masquerade libvirt tidak mencakup subnet itu. Paket bisa keluar, tapi '''balasan tidak bisa pulang'''.

'''Pelajaran di kantor''': gejala '''"router bisa internetan, tapi semua PC tidak"''' adalah tanda klasik masalah NAT (rule hilang, disabled, atau <code>out-interface</code> salah setelah port WAN diganti).

'''Alternatif tanpa NAT''': kalau "dunia luar" diberi tahu jalan pulangnya, NAT tidak dibutuhkan. Misalnya route di host <code>192.168.10.0/24 via 192.168.122.212</code> membuat host bisa ping PC1 langsung. Ini '''routing murni''', cara jaringan internal besar menyambungkan antar subnet. NAT hanya terpaksa dipakai di batas ke internet karena IP privat tidak bisa di-routing di sana.

== Referensi ==
* [https://help.mikrotik.com/docs/spaces/ROS/pages/24805500/DHCP MikroTik Docs: DHCP]
* [https://help.mikrotik.com/docs/spaces/ROS/pages/37748767/DNS MikroTik Docs: DNS]
* [https://help.mikrotik.com/docs/spaces/ROS/pages/3211299/NAT MikroTik Docs: NAT]
* [https://help.mikrotik.com/docs/spaces/ROS/pages/328088/IP+Addressing MikroTik Docs: IP Addressing]

[[Category:Networking]]

Mikrotik 2: Kantor Mini

2026-10-23T03:16:24Z

SanzSkuy: Created page with "Fase 1 dari roadmap: membangun '''"kantor mini"''', yaitu satu router MikroTik sebagai gateway, beberapa PC yang mendapat IP otomatis, dan semuanya bisa internetan. Konfigurasi dilakukan lewat '''Winbox 4''', dengan padanan CLI di setiap langkah. __TOC__ == Tujuan == * Paham peran IP address, gateway, DHCP, DNS, dan NAT di jaringan kantor. * Paham beda '''switching''' (Layer 2) dan '''routing''' (Layer 3). * Bisa membaca kondisi router: siapa yang tersambung, dapat IP..."

Fase 1 dari roadmap: membangun '''"kantor mini"''', yaitu satu router MikroTik sebagai gateway, beberapa PC yang mendapat IP otomatis, dan semuanya bisa internetan. Konfigurasi dilakukan lewat '''Winbox 4''', dengan padanan CLI di setiap langkah.

__TOC__

== Tujuan ==
* Paham peran IP address, gateway, DHCP, DNS, dan NAT di jaringan kantor.
* Paham beda '''switching''' (Layer 2) dan '''routing''' (Layer 3).
* Bisa membaca kondisi router: siapa yang tersambung, dapat IP apa, lewat mana.

== Topologi ==
<pre>
[NAT]
│
ether1 (WAN, DHCP client)
192.168.122.212/24
│
[MikroTikCHR-1]
ether2 / \ ether3
192.168.10.1/24 192.168.11.1/24
│ │
[Switch1] [Switch2]
/ | \ / \
PC1 PC2 PC3 PC4 PC5
</pre>

* '''NAT node''' dari [[Belajar MikroTik Part 1|Part 1]] tetap di <code>ether1</code>.
* '''Ethernet switch''' dan '''VPCS''' adalah perangkat bawaan GNS3 (kategori Switches dan End devices).

'''Pengingat''': setelah reboot host, jalankan ulang aturan <code>DOCKER-USER</code> dari Part 1, kalau tidak traffic lab tidak bisa keluar ke internet.

== Konsep dasar ==

=== IP address, subnet, dan alamat spesial ===
<code>/24</code> berarti 24 bit pertama adalah bagian '''network''', 8 bit terakhir bagian '''host'''.

<pre>
192.168.10. | 00000000 → .0 semua bit host 0 = alamat network
192.168.10. | 00000001 → .1 host pertama
192.168.10. | 11111110 → .254 host terakhir
192.168.10. | 11111111 → .255 semua bit host 1 = broadcast
</pre>

{| class="wikitable"
! Alamat !! Fungsi !! Bisa dipakai perangkat?
|-
| <code>192.168.10.0</code> || Network address (identitas subnet) || Tidak
|-
| <code>192.168.10.1</code> – <code>.254</code> || Alamat host (254 host) || Ya
|-
| <code>192.168.10.255</code> || Broadcast (ke semua di subnet) || Tidak
|}

'''Kapan menulis <code>.1/24</code> dan kapan <code>.0/24</code>?'''
* '''IP → Addresses''' menjawab "IP gua apa?" → alamat host, misalnya <code>192.168.10.1/24</code>. Kolom Network dihitung otomatis.
* '''Route, DHCP Network, firewall''' menjawab "network yang mana?" → alamat network, misalnya <code>192.168.10.0/24</code>.

'''Range IP privat''' (tidak dikenal di internet): <code>10.0.0.0/8</code>, <code>172.16.0.0/12</code> (172.16–172.31), <code>192.168.0.0/16</code>.

=== Gateway ===
Gateway adalah "pintu keluar" PC. Tujuan di luar subnet sendiri dikirim ke gateway.

'''Aturan emas''': gateway '''harus berada di subnet yang sama''' dengan PC. Biasanya berupa IP router di interface tersebut. Gateway di <code>.1</code> hanya kebiasaan, bukan aturan.

=== ARP ===
Di dalam satu segmen, frame Ethernet dikirim berdasarkan '''MAC address''', bukan IP. '''ARP''' menerjemahkan '''IP → MAC''' di dalam satu segmen.

# '''Request (broadcast)''': "Siapa yang punya <code>192.168.10.1</code>? Kasih tahu <code>192.168.10.100</code>."
# '''Reply (unicast)''': "Itu gua, MAC gua <code>0C:B3:C6:FB:00:01</code>."
# Hasilnya disimpan di '''tabel ARP''' (cache) dan kedaluwarsa setelah beberapa waktu.

'''Poin penting''': saat PC ping <code>8.8.8.8</code>, yang di-ARP adalah '''gateway''', bukan <code>8.8.8.8</code>. Di setiap lompatan, '''IP tujuan tetap sama''', tapi '''MAC tujuan berganti'''. Inilah beda Layer 2 (antar tetangga) dan Layer 3 (ujung ke ujung).

Switch juga punya tabel MAC, tapi isinya "MAC ini ada di port mana". Switch tidak peduli IP.

=== DHCP ===
PC yang baru tersambung belum punya IP, gateway, maupun DNS. DHCP membagikannya secara otomatis lewat proses '''DORA''':
# '''Discover''': PC broadcast "ada DHCP server?"
# '''Offer''': server menawarkan IP + gateway + DNS
# '''Request''': PC menerima tawaran
# '''Ack''': server mengonfirmasi dan mencatat lease

Di RouterOS, DHCP dipecah menjadi tiga bagian:
{| class="wikitable"
! Bagian !! Menjawab !! Alasan dipisah
|-
| '''Pool''' || IP mana yang boleh dibagikan? || Pool dipakai ulang oleh fitur lain (VPN, PPPoE, Hotspot)
|-
| '''Network''' || Info apa yang diberikan (gateway, DNS)? || Satu server bisa melayani banyak subnet (lewat relay)
|-
| '''Server''' || Siapa yang melayani, di interface mana? || Mengikat semuanya ke satu segmen
|}

* '''Lease time''' (default 30 menit): lama IP "disewakan". PC memperpanjang sebelum habis, dan IP kembali ke pool kalau PC pergi.
* '''Kenapa pool mulai dari <code>.100</code>''': <code>.2–.99</code> disisakan untuk perangkat ber-IP tetap (server, printer, access point, CCTV).

'''Di mana DHCP server diletakkan?''' Broadcast DHCP '''tidak menyeberang router''', jadi DHCP server harus berada di segmen yang sama dengan client, atau memakai '''DHCP relay''' yang meneruskan permintaan ke server di network lain.

{| class="wikitable"
! Skenario !! Lokasi DHCP server
|-
| Rumah || Modem/router ISP
|-
| Kantor kecil-menengah || Router MikroTik, satu server per segmen/VLAN
|-
| Kantor besar || Server khusus (Windows Server, Kea, dnsmasq) + DHCP relay di router
|}

Di lab ini CHR berperan ganda: '''client''' di sisi WAN (dapat IP dari dnsmasq libvirt) dan '''server''' di sisi LAN.

'''Satu segmen = satu DHCP server.''' Dua server di segmen yang sama membuat PC bisa mendapat konfigurasi yang salah. Kasus klasiknya '''rogue DHCP''': router Wi-Fi rumahan yang dicolok ke jaringan kantor.

=== DNS ===
PC diarahkan ke router (<code>192.168.10.1</code>) sebagai DNS server. Router meneruskan pertanyaan ke '''Dynamic Servers''' (<code>192.168.122.1</code>, didapat dari DHCP di WAN) dan menyimpan jawabannya di cache.

* '''Allow Remote Requests''' harus dicentang, karena defaultnya DNS router hanya untuk dirinya sendiri.
* Keuntungan lewat router: cache, kontrol terpusat (nama lokal, blokir domain), dan ganti DNS upstream cukup di satu tempat.

=== NAT (masquerade) ===
IP privat tidak bisa dibalas oleh internet. '''Masquerade''' mengganti '''IP sumber''' paket yang keluar lewat WAN menjadi IP router, lalu mencatat pemetaannya di '''connection tracking''' supaya balasan bisa dikembalikan ke PC yang benar.

* '''Chain <code>srcnat</code>''': yang diubah alamat sumber, diproses setelah keputusan routing.
* '''Out. Interface <code>ether1</code>''': hanya traffic ke arah WAN yang di-NAT.
* '''<code>masquerade</code> vs <code>src-nat</code>''': masquerade otomatis memakai IP yang sedang menempel di interface, cocok untuk IP WAN dinamis. <code>src-nat</code> dipakai kalau IP publik statis.

'''Kenapa NAT ada di menu Firewall?''' Firewall RouterOS adalah mesin pemroses paket dengan beberapa tabel (Filter, NAT, Mangle, Raw), persis seperti <code>iptables</code> di Linux:
<syntaxhighlight lang="bash">
# padanan rule masquerade di Linux
iptables -t nat -A POSTROUTING -o ether1 -j MASQUERADE
</syntaxhighlight>

'''Fakta menarik''': <code>virbr0</code> + dnsmasq dari libvirt (Part 1) melakukan hal yang sama persis dengan router di lab ini: IP gateway, DHCP, DNS, dan masquerade. Lab ini juga '''double NAT''': paket di-masquerade CHR, lalu di-NAT lagi oleh <code>virbr0</code>. Banyak kantor sungguhan juga begini (router kantor di belakang modem ISP).

=== Perjalanan satu ping ===
<pre>
PC1 (192.168.10.100) ping 8.8.8.8
│ "bukan tetangga → kirim ke gateway" (ARP gateway → dapat MAC router)
▼
CHR ether2 ── routing: 0.0.0.0/0 via 192.168.122.1 ── keluar ether1
│ srcnat masquerade: src 192.168.10.100 → 192.168.122.212
▼
virbr0 (host) ── masquerade lagi: src → IP host
▼
Internet ── balasan kembali, setiap NAT membalik alamatnya ── PC1 ✅
</pre>

== Konfigurasi LAN pertama ==

=== Konek Winbox ===
Isi '''Connect To''' dengan IP WAN CHR (contoh <code>192.168.122.212</code>), login <code>admin</code>. Konek lewat MAC di tab '''Neighbors''' belum tentu berhasil melalui <code>virbr0</code>, jadi pakai IP.

=== Langkah-langkah ===
{| class="wikitable"
! # !! Winbox !! Isian !! CLI
|-
| 1 || '''IP → Addresses''' → New || Address <code>192.168.10.1/24</code>, Interface <code>ether2</code>, Comment <code>LAN</code> || <code>/ip address add address=192.168.10.1/24 interface=ether2 comment=LAN</code>
|-
| 2 || '''IP → Pool''' → New || Name <code>pool-lan</code>, Addresses <code>192.168.10.100-192.168.10.200</code> || <code>/ip pool add name=pool-lan ranges=192.168.10.100-192.168.10.200</code>
|-
| 3 || '''IP → DHCP Server''' → tab '''Networks''' → New || Address <code>192.168.10.0/24</code>, Gateway <code>192.168.10.1</code>, DNS <code>192.168.10.1</code> || <code>/ip dhcp-server network add address=192.168.10.0/24 gateway=192.168.10.1 dns-server=192.168.10.1</code>
|-
| 4 || '''IP → DHCP Server''' → tab '''DHCP''' → New || Name <code>dhcp-lan</code>, Interface <code>ether2</code>, Address Pool <code>pool-lan</code> || <code>/ip dhcp-server add name=dhcp-lan interface=ether2 address-pool=pool-lan disabled=no</code>
|-
| 5 || '''IP → DNS''' || Centang '''Allow Remote Requests''' || <code>/ip dns set allow-remote-requests=yes</code>
|-
| 6 || '''IP → Firewall''' → tab '''NAT''' → New || General: Chain <code>srcnat</code>, Out. Interface <code>ether1</code>; Action: <code>masquerade</code> || <code>/ip firewall nat add chain=srcnat out-interface=ether1 action=masquerade comment="NAT ke internet"</code>
|}

'''Catatan langkah 1''': entri <code>192.168.122.x</code> di <code>ether1</code> dengan flag '''D''' (Dynamic) adalah IP WAN dari DHCP client. Jangan dihapus. Router memang punya '''satu IP di setiap network''' yang ia sambungkan, dan network di interface berbeda '''tidak boleh tumpang tindih'''.

'''Peringatan keamanan''': CHR ini belum punya firewall filter, dan <code>allow-remote-requests=yes</code> membuat DNS router bisa ditanya dari sisi WAN. Aman di lab, tapi di router sungguhan harus diblok (Fase 3).

=== Trik Winbox ===
* Tombol '''DHCP Setup''' mengerjakan langkah 2–4 sekaligus. Pakai setelah paham cara manualnya.
* '''Terminal''' tersedia di dalam Winbox. Jalankan <code>/ip firewall nat export</code> untuk melihat padanan CLI dari apa yang diklik di GUI.
* '''Safe Mode''': kalau koneksi putus karena salah setting, perubahan otomatis dibatalkan. Biasakan menyalakannya.

== Verifikasi ==
Di VPCS:
<syntaxhighlight lang="text">
ip dhcp
show ip
ping 192.168.10.1
ping 8.8.8.8
ping google.com
trace 8.8.8.8
show arp
</syntaxhighlight>
<code>trace</code> menampilkan hop lewat <code>192.168.10.1</code> lalu <code>192.168.122.1</code>, jadi double NAT terlihat langsung.

=== Melihat perangkat yang tersambung ===
{| class="wikitable"
! Menu !! Menampilkan !! Keterbatasan
|-
| '''IP → DHCP Server → Leases''' || IP, MAC, hostname, status (<code>bound</code>) || Hanya perangkat yang memakai DHCP
|-
| '''IP → ARP''' || Perangkat yang baru-baru ini berkomunikasi, termasuk IP statis || Perangkat yang diam bisa tidak muncul
|-
| '''Bridge → Hosts''' || MAC per port fisik || Hanya untuk port anggota bridge
|-
| '''IP → Neighbors''' || Perangkat jaringan (MNDP/LLDP/CDP) || PC biasa umumnya tidak muncul
|-
| '''Tools → IP Scan''' || Scan aktif satu range || Harus dijalankan manual
|}

Kombinasi di kantor: '''Leases''' (perangkat siapa), '''ARP''' (siapa yang aktif), '''Bridge Hosts''' (colok di port mana).

Melihat paket ARP secara langsung: klik kanan kabel di GNS3 → '''Start capture''', lalu di PC jalankan <code>clear arp</code> dan <code>ping 192.168.10.1</code>.

== LAN kedua dan routing antar subnet ==

=== Konfigurasi ===
{| class="wikitable"
! Bagian !! Isian
|-
| IP → Addresses || <code>192.168.11.1/24</code> di <code>ether3</code> (beri comment, misalnya <code>LAN2</code>)
|-
| IP → Pool || <code>pool-lan2</code>: <code>192.168.11.100-192.168.11.200</code>
|-
| DHCP → Networks || <code>192.168.11.0/24</code>, gateway & DNS <code>192.168.11.1</code>
|-
| DHCP → DHCP || Server baru di <code>ether3</code> dengan <code>pool-lan2</code>
|-
| NAT || '''Tidak perlu diubah''': rule mencocokkan <code>out-interface=ether1</code>, jadi semua subnet yang keluar ke WAN otomatis di-masquerade
|}

=== Kenapa PC1 bisa ping PC4? ===
# PC1 melihat <code>192.168.11.x</code> bukan tetangga → kirim ke gateway <code>192.168.10.1</code>.
# Router sudah mengenal kedua network sebagai '''connected route''' (lihat '''IP → Routes'''):
<pre>
DAC 192.168.10.0/24 → ether2
DAC 192.168.11.0/24 → ether3
DAd 0.0.0.0/0 → 192.168.122.1 (dari DHCP client)
</pre>
:<code>D</code> = dynamic, <code>A</code> = active, <code>C</code> = connected.
# Router meng-ARP PC4 di sisi <code>ether3</code> lalu meneruskan paket.
# '''Tidak kena NAT''', karena traffic keluar lewat <code>ether3</code>, bukan <code>ether1</code>. PC4 melihat IP asli PC1.
# '''Tidak ada yang memblokir''', karena belum ada firewall filter.

=== Switching vs routing ===
{| class="wikitable"
! Tes !! Hasil <code>trace</code> !! Yang bekerja
|-
| PC1 → PC2 (satu switch) || Langsung sampai || '''Switch''' (Layer 2). Router tidak terlibat.
|-
| PC1 → PC4 (beda subnet) || Satu hop lewat <code>192.168.10.1</code> || '''Router''' (Layer 3)
|}

'''Implikasi di kantor''': memisahkan subnet '''tidak sama dengan isolasi'''. Secara default router menyambungkan semua subnet. Untuk memisahkan misalnya Wi-Fi tamu atau CCTV dari jaringan karyawan, dibutuhkan '''firewall filter di chain <code>forward</code>''' (Fase 3).

== Kesalahan umum ==
{| class="wikitable"
! Gejala !! Penyebab !! Solusi
|-
| PC dapat IP tapi tidak bisa internetan setelah ganti subnet || Gateway/DNS di DHCP Network masih memakai alamat subnet lama. PC tidak bisa meng-ARP gateway yang bukan tetangganya. || Gateway & DNS = IP router di subnet baru
|-
| Router punya dua IP di satu interface setelah ganti subnet || Menambah entri baru tanpa menghapus yang lama || Edit entri yang ada (double-click)
|-
| PC masih memakai IP lama || Lease lama belum diperbarui || Jalankan <code>ip dhcp</code> lagi di VPCS
|-
| Satu segmen mendadak dapat gateway aneh || Rogue DHCP (dua DHCP server di satu segmen) || Cari dan cabut DHCP server liar
|-
| Router bingung meneruskan paket || Dua interface memakai subnet yang tumpang tindih || Pakai subnet berbeda di setiap interface
|-
| <code>failure: dhcp-client on that interface already exists</code> || Appliance CHR sudah membawa DHCP client di <code>ether1</code> || Normal, abaikan
|-
| Parameter ditolak || <code>disable=no</code> || Yang benar <code>disabled=no</code>
|}

== Latihan ==
# '''Pindah subnet''': ubah LAN pertama menjadi <code>10.10.10.0/24</code> (gateway <code>.1</code>, pool <code>.50–.99</code>). Ada empat isian yang harus ikut berubah. Apakah rule NAT perlu diubah?
# '''Static lease''': buat PC1 selalu mendapat <code>192.168.10.10</code>, sementara PC lain tetap acak dari pool.
#* Bolehkah static lease memakai IP di luar pool? Kenapa justru bisa jadi ide bagus?
#* Bagaimana membuat PC1 memakai IP barunya?
#* Apa yang bisa terjadi kalau static lease memakai IP di dalam pool yang sedang dipakai PC lain?
# '''Sengaja dirusak''': disable rule NAT. Tebak dulu: <code>/ping 8.8.8.8</code> dari router masih jalan? Dari PC1? Tes, lalu jelaskan kenapa hasilnya berbeda.

== Selanjutnya ==
Part 3: bridge dan VLAN, yaitu cara satu router melayani banyak segmen lewat satu kabel.

== Referensi ==
* [https://help.mikrotik.com/docs/spaces/ROS/pages/24805500/DHCP MikroTik Docs: DHCP]
* [https://help.mikrotik.com/docs/spaces/ROS/pages/37748767/DNS MikroTik Docs: DNS]
* [https://help.mikrotik.com/docs/spaces/ROS/pages/3211299/NAT MikroTik Docs: NAT]
* [https://help.mikrotik.com/docs/spaces/ROS/pages/328088/IP+Addressing MikroTik Docs: IP Addressing]

[[Category:Networking]]

Networking

2026-10-23T03:16:10Z

SanzSkuy:

= Networking =
* [[Model OSI]]
* [[Lapisan Transport (TCP dan UDP)]]
* [[Kelas Alamat IP]]
* [[Subnetting 1]]
* [[VLSM]]
* [[Magic Number Method & Subnetting Jaringan Besar]]
* [[Subnetting: Contoh Oktet ke-3 vs ke-4]]
* [[Private IP Address (RFC 1918)]]
* [[Ethernet & Layer 2 (Data Link)]]
* [[Media Koneksi Ethernet (Layer 1)]]
* [[Perangkat Jaringan: Hub, Switch, dan Router]]

= Mikrotik =
* [[Mikrotik 1: Install GNS3 Arch Linux]]
* [[Mikrotik 2: Kantor Mini]]

= Cisco =
* [[Cisco IOS]]
* [[Perintah Dasar Cisco IOS]]

== Cisco Lab ==
* [[Lab 0.1 - Basic Device Hardening]]

Mikrotik 1: Install GNS3 Arch Linux

2026-10-22T09:32:58Z

SanzSkuy: Created page with "Halaman ini mencatat setup lab MikroTik virtual pakai '''GNS3''' di '''Arch Linux''', dari install sampai router pertama bisa nge-ping internet. Semua error yang muncul selama setup juga dicatat, lengkap dengan penyebab dan solusinya. __TOC__ == Tujuan == * Punya lab MikroTik tanpa beli hardware. * Router virtual bisa diakses dari host (WebFig) dan bisa keluar ke internet. * Paham istilah dasar: CHR, appliance, template, libvirt, <code>virbr0</code>. == Konsep dan ist..."

Halaman ini mencatat setup lab MikroTik virtual pakai '''GNS3''' di '''Arch Linux''', dari install sampai router pertama bisa nge-ping internet. Semua error yang muncul selama setup juga dicatat, lengkap dengan penyebab dan solusinya.

__TOC__

== Tujuan ==
* Punya lab MikroTik tanpa beli hardware.
* Router virtual bisa diakses dari host (WebFig) dan bisa keluar ke internet.
* Paham istilah dasar: CHR, appliance, template, libvirt, <code>virbr0</code>.

== Konsep dan istilah ==

=== RouterOS dan CHR ===
'''RouterOS''' adalah sistem operasi router MikroTik. '''CHR (Cloud Hosted Router)''' adalah RouterOS versi x86 yang dijalankan sebagai VM.

* Fiturnya sama dengan RouterOS di router fisik: bridge, NAT, firewall, VLAN, OSPF, BGP, VPN.
* Ringan: cukup RAM beberapa ratus MB per router, jadi bisa jalan banyak router sekaligus.
* Lisensi gratis dibatasi upload '''1 Mbps per interface''', tapi semua fitur tetap jalan. Cukup buat belajar.

=== Tools konfigurasi ===
{| class="wikitable"
! Tool !! Keterangan
|-
| '''WebFig''' || Antarmuka web bawaan RouterOS. Tanpa install, cukup buka IP router di browser. Hanya bisa konek lewat IP.
|-
| '''Winbox 4''' || Aplikasi native (Windows, macOS, Linux). Bisa konek lewat '''MAC address''', berguna kalau router belum punya IP.
|-
| '''CLI''' || Lewat console/telnet/SSH. Paling lengkap, dan yang dipakai di halaman ini.
|}

=== GNS3: appliance vs template ===
* '''Template''': perangkat yang siap di-drag ke canvas.
* '''Appliance''': file resep (<code>.gns3a</code>) yang otomatis membuat template, lengkap dengan setting RAM, adapter, console, serta nama file dan checksum image yang dibutuhkan.
* GNS3 '''tidak membawa image''' vendor. Image CHR tetap diambil dari mikrotik.com.

Di katalog appliance ada banyak model MikroTik (CCR, RB, CRS, dll). Buat belajar, cukup pakai '''MikroTik CHR'''.

=== libvirt dan virbr0 ===
* '''libvirt''': lapisan manajemen virtualisasi di Linux (daemon <code>libvirtd</code>, tool <code>virsh</code>). Mengatur VM, storage, dan network virtual.
* '''virbr0''' (''virtual bridge''): switch virtual di host yang dibuat oleh network <code>default</code> libvirt. Fungsinya:
** gateway lab (<code>192.168.122.1</code>),
** DHCP via dnsmasq (range <code>192.168.122.x</code>),
** NAT supaya lab bisa keluar lewat internet host.

Node '''NAT''' di GNS3 memakai <code>virbr0</code> ini.

<pre>
CHR (GNS3) ── NAT node ── virbr0 (host) ── internet
│
Browser/Winbox di host
</pre>

'''Efek ke host''': koneksi internet asli tidak berubah. libvirt hanya menambah aturan NAT untuk <code>192.168.122.0/24</code>, menyalakan <code>ip_forward</code>, dan menjalankan dnsmasq khusus <code>virbr0</code>. Pastikan subnet ini tidak bentrok dengan jaringan asli.

== Instalasi ==

=== 1. Upgrade sistem ===
<syntaxhighlight lang="bash">
sudo pacman -Syu
</syntaxhighlight>
Wajib, untuk menghindari partial upgrade (lihat [[#Masalah 1: partial upgrade QEMU|Masalah 1]]).

=== 2. Dependensi ===
<syntaxhighlight lang="bash">
paru -S --needed qemu docker vpcs dynamips libvirt ubridge inetutils
</syntaxhighlight>
* <code>--needed</code> melewati paket yang sudah terinstall.
* Kalau <code>qemu-full</code> sudah ada, <code>qemu</code> tidak perlu dipasang lagi.
* <code>vpcs</code>, <code>dynamips</code>, <code>ubridge</code> dari AUR.
* <code>inetutils</code> menyediakan <code>telnet</code> untuk console.

=== 3. GNS3 ===
<syntaxhighlight lang="bash">
paru -S gns3-server gns3-gui
</syntaxhighlight>

=== 4. Group user dan service ===
<syntaxhighlight lang="bash">
for g in ubridge libvirt kvm docker wireshark; do
getent group $g >/dev/null && sudo gpasswd -a $USER $g || echo "group $g belum ada"
done

sudo systemctl enable --now libvirtd docker
reboot
</syntaxhighlight>
Group <code>wireshark</code> baru ada setelah <code>sudo pacman -S wireshark-qt</code>. Setelah reboot, cek dengan <code>groups</code>.

=== 5. Network default libvirt ===
<syntaxhighlight lang="bash">
sudo virsh net-list --all
# kalau "default" belum ada:
sudo virsh net-define /usr/share/libvirt/networks/default.xml
sudo virsh net-start default
sudo virsh net-autostart default
ip a show virbr0
</syntaxhighlight>
Pakai <code>sudo</code> supaya <code>virsh</code> konek ke koneksi ''system'', bukan ''session''.

=== 6. Console terminal ===
GNS3 default memakai <code>xterm</code>. Pilih salah satu:
* <code>sudo pacman -S xterm</code>, atau
* ganti di '''Edit → Preferences → General → Console applications''', contoh:
<syntaxhighlight lang="text">
kitty --title "%d" telnet %h %p
alacritty -t "%d" -e telnet %h %p
konsole -p tabtitle=%d -e telnet %h %p
</syntaxhighlight>
(<code>%h</code> = host, <code>%p</code> = port, <code>%d</code> = nama node)

=== 7. Template MikroTik CHR ===
# Jalankan <code>gns3</code>, pilih '''Run appliances on my local computer'''.
# '''File → New template → Install an appliance from the GNS3 server'''.
# Cari '''MikroTik CHR''', klik '''Install'''.
# Lihat '''nama file dan versi''' yang diminta wizard (contoh: <code>chr-7.22.1.img</code>).
# Download '''Raw disk image''' versi yang sama dari mikrotik.com, lalu unzip:
<syntaxhighlight lang="bash">
unzip chr-7.22.1.img.zip
md5sum chr-7.22.1.img # harus sama dengan checksum di wizard
</syntaxhighlight>
# '''Import''' file <code>.img</code> (bukan <code>.zip</code>), lalu Finish.

Template muncul di panel '''Routers'''.

== Hello World ==

=== Router pertama ===
# Drag '''MikroTik CHR''' ke canvas, klik kanan → '''Start'''.
# Double-click node untuk membuka console.
# Login <code>admin</code>, password kosong. Jawab <code>n</code> untuk lisensi, lalu set password baru.

<syntaxhighlight lang="text">
/system identity set name=hello-world
/system resource print
/interface print
</syntaxhighlight>
Prompt berubah jadi <code>[admin@hello-world] ></code>. Hello world selesai.

=== Sambung ke internet ===
# Drag node '''NAT''' ke canvas, sambungkan ke <code>ether1</code> CHR.
# Di console CHR:
<syntaxhighlight lang="text">
/ip dhcp-client print
/ip address print
/ip route print
/ping 192.168.122.1
/ping 8.8.8.8
</syntaxhighlight>
Appliance CHR sudah membawa DHCP client di <code>ether1</code>, jadi menambah lagi akan memunculkan <code>failure: dhcp-client on that interface already exists</code>. Itu normal. (Kalau perlu menambah manual, parameternya <code>disabled=no</code>, bukan <code>disable=no</code>.)

=== Buka WebFig ===
<syntaxhighlight lang="bash">
ping -c 3 192.168.122.212 # ganti dengan IP CHR
</syntaxhighlight>
Lalu buka <code>http://192.168.122.212</code> di browser host. Kalau tidak terbuka, cek <code>/ip service print</code> dan pastikan <code>www</code> tidak disabled.

== Masalah yang ditemui ==

=== Masalah 1: partial upgrade QEMU ===
'''Gejala'''
<pre>
error: failed to prepare transaction (could not satisfy dependencies)
:: installing qemu-common (11.1.2-1) breaks dependency 'qemu-common=11.1.1-1' required by qemu-audio-alsa
...
</pre>
'''Penyebab''': repo sudah punya QEMU 11.1.2, sistem masih 11.1.1. Menginstall <code>qemu</code> menarik <code>qemu-common</code> baru, sedangkan puluhan paket QEMU lain masih mengunci versi lama. Arch tidak mendukung partial upgrade.

'''Solusi''': <code>sudo pacman -Syu</code>, lalu ulangi install dependensi tanpa <code>qemu</code> (sudah ada lewat <code>qemu-full</code>).

=== Masalah 2: gns3server crash, <code>No module named 'langchain'</code> ===
'''Gejala'''
<pre>
CRITICAL gns3server.server:331 Critical error while running the server: No module named 'langchain'
File ".../gns3server/agent/gns3_copilot/gns3_client/gns3_project_info.py", line 39, in <module>
from langchain.tools import BaseTool
ModuleNotFoundError: No module named 'langchain'
</pre>
'''Penyebab''': GNS3 versi baru (3.x alpha di AUR) meng-import modul fitur AI copilot/MCP tanpa pengaman, padahal dependensinya opsional dan tidak ikut terinstall. Pola serupa dilaporkan untuk modul <code>mcp</code> di [https://github.com/GNS3/gns3-server/issues/2794 GNS3 issue #2794].

'''Solusi''':
* Install dependensi yang kurang (<code>python-langchain</code>, <code>python-langchain-core</code>, <code>python-mcp</code>, dari repo atau AUR), lalu jalankan <code>gns3server</code> dan ulangi sampai tidak ada <code>ModuleNotFoundError</code> lagi.
* Alternatif: bungkus import tersebut dengan <code>try/except ModuleNotFoundError</code> (hilang saat update), atau pakai versi stabil.

=== Masalah 3: import image CHR gagal ===
'''Gejala'''
<pre>
Cannot install MikroTik CHR version 7.22.1: File chr-7.22.1.img with checksum a67290634f489071eae2fd99dcadba86 not found
The file is compressed with 'zip', it must be uncompressed first
Could not upload image chr-7.22.1.img: File '/home/haidhi/GNS3/images/QEMU/chr-7.22.1.img' already exists
</pre>
'''Penyebab''':
* Yang di-import file <code>.zip</code>, bukan <code>.img</code> hasil unzip.
* Sudah ada file dengan nama sama dari percobaan sebelumnya, sehingga GNS3 menolak menimpa.
* Wizard appliance mencocokkan '''nama file dan checksum''' secara persis.

'''Solusi'''
<syntaxhighlight lang="bash">
file ~/GNS3/images/QEMU/chr-7.22.1.img
md5sum ~/GNS3/images/QEMU/chr-7.22.1.img
# kalau salah:
rm ~/GNS3/images/QEMU/chr-7.22.1.img*
unzip chr-7.22.1.img.zip && md5sum chr-7.22.1.img
</syntaxhighlight>
Lalu ulangi wizard dan import file <code>.img</code>. Kalau versi yang diminta sudah tidak tersedia, buat template QEMU manual (lihat [[#Catatan: template manual|catatan]]).

=== Masalah 4: console tidak terbuka, <code>xterm</code> tidak ada ===
'''Gejala'''
<pre>
Could not start Telnet console with command 'xterm -T "MikroTikCHR-1" -e "telnet localhost 5000"': [Errno 2] No such file or directory: 'xterm'
</pre>
'''Penyebab''': GNS3 default memakai <code>xterm</code>, yang tidak terinstall di Arch.

'''Solusi''': install <code>xterm</code> atau ganti console command (lihat [[#6. Console terminal|langkah 6]]).

=== Masalah 5: <code>NAT interface virbr0 is missing</code> ===
'''Gejala'''
<pre>
Error while creating node from template: NAT interface virbr0 is missing, please install libvirt
</pre>
'''Penyebab''': <code>libvirtd</code> sudah jalan, tapi network <code>default</code> belum dinyalakan, sehingga <code>virbr0</code> belum ada. Daemon hidup ≠ network hidup.

'''Solusi''': [[#5. Network default libvirt|langkah 5]]. Kalau <code>net-start</code> gagal, cek apakah <code>dnsmasq</code> dan <code>iptables-nft</code>/nftables sudah terpasang.

Catatan: baris log <code>Libvirt doesn't support VirtualBox API version ...</code> tidak berbahaya.

'''Kenapa <code>virbr0</code> statusnya DOWN?'''
<pre>
virbr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> ... state DOWN
</pre>
<code>NO-CARRIER</code> berarti belum ada perangkat yang tersambung ke bridge. Begitu node NAT di GNS3 aktif, statusnya berubah jadi UP. Normal.

=== Masalah 6: CHR dapat IP, tapi ping internet timeout ===
'''Gejala'''
<pre>
0 D 192.168.122.212/24 192.168.122.0 ether1 main
/ping 8.8.8.8
sent=9 received=0 packet-loss=100%
</pre>
DHCP jalan (IP didapat), tapi traffic keluar tidak tembus.

'''Penyebab''': Docker mengatur policy chain <code>FORWARD</code> menjadi <code>DROP</code>, sehingga traffic dari <code>virbr0</code> dibuang sebelum di-NAT keluar.

'''Diagnosis'''
<syntaxhighlight lang="bash">
sysctl net.ipv4.ip_forward # harus 1
sudo iptables -S FORWARD | head # cari: -P FORWARD DROP
</syntaxhighlight>

'''Solusi''': izinkan traffic <code>virbr0</code> di chain <code>DOCKER-USER</code> (chain yang memang disediakan Docker untuk aturan user):
<syntaxhighlight lang="bash">
sudo iptables -I DOCKER-USER -i virbr0 -j ACCEPT
sudo iptables -I DOCKER-USER -o virbr0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
</syntaxhighlight>
* Aturan pertama: izinkan traffic yang masuk dari lab.
* Aturan kedua: izinkan balasan yang kembali ke lab.

Aturan ini '''hilang setelah reboot''' atau restart Docker. Jalankan ulang sebelum nge-lab, atau buat permanen nanti.

== Catatan: template manual ==
Kalau tidak memakai appliance:
<syntaxhighlight lang="bash">
qemu-img convert -f raw -O qcow2 chr-*.img chr.qcow2
</syntaxhighlight>
'''Edit → Preferences → QEMU → QEMU VMs → New''':
* Binary: <code>qemu-system-x86_64</code>, RAM: 256 MB, disk: <code>chr.qcow2</code>
* Console: <code>telnet</code>
* Adapter: 4+, tipe <code>virtio-net-pci</code> (ganti <code>e1000</code> kalau interface tidak muncul)
* Advanced: centang '''Use as a linked base VM'''

== Ringkasan ==
{| class="wikitable"
! Masalah !! Penyebab !! Solusi
|-
| Dependency QEMU rusak || Partial upgrade || <code>pacman -Syu</code>
|-
| <code>No module named 'langchain'</code> || Dependensi opsional GNS3 alpha tidak terinstall || Install modul yang kurang
|-
| Image CHR tidak ditemukan || Import <code>.zip</code> / file lama tertinggal / checksum beda || Hapus file lama, unzip, import <code>.img</code>
|-
| <code>xterm</code> tidak ada || Console default GNS3 || Install xterm / ganti console command
|-
| <code>virbr0 is missing</code> || Network <code>default</code> belum start || <code>virsh net-start default</code>
|-
| Ping internet timeout || Docker <code>FORWARD DROP</code> || Aturan <code>DOCKER-USER</code> untuk <code>virbr0</code>
|}

Networking

2026-10-22T09:32:46Z

SanzSkuy:

= Networking =
* [[Model OSI]]
* [[Lapisan Transport (TCP dan UDP)]]
* [[Kelas Alamat IP]]
* [[Subnetting 1]]
* [[VLSM]]
* [[Magic Number Method & Subnetting Jaringan Besar]]
* [[Subnetting: Contoh Oktet ke-3 vs ke-4]]
* [[Private IP Address (RFC 1918)]]
* [[Ethernet & Layer 2 (Data Link)]]
* [[Media Koneksi Ethernet (Layer 1)]]
* [[Perangkat Jaringan: Hub, Switch, dan Router]]

= Mikrotik =
* [[Mikrotik 1: Install GNS3 Arch Linux]]

= Cisco =
* [[Cisco IOS]]
* [[Perintah Dasar Cisco IOS]]

== Cisco Lab ==
* [[Lab 0.1 - Basic Device Hardening]]

Networking

2026-10-22T09:31:24Z

SanzSkuy: SanzSkuy moved page CCNA to Networking without leaving a redirect

= Networking =
* [[Model OSI]]
* [[Lapisan Transport (TCP dan UDP)]]
* [[Kelas Alamat IP]]
* [[Subnetting 1]]
* [[VLSM]]
* [[Magic Number Method & Subnetting Jaringan Besar]]
* [[Subnetting: Contoh Oktet ke-3 vs ke-4]]
* [[Private IP Address (RFC 1918)]]
* [[Ethernet & Layer 2 (Data Link)]]
* [[Media Koneksi Ethernet (Layer 1)]]
* [[Perangkat Jaringan: Hub, Switch, dan Router]]

= Cisco =
* [[Cisco IOS]]
* [[Perintah Dasar Cisco IOS]]

= Lab =
* [[Lab 0.1 - Basic Device Hardening]]

Deploy app bare-metal

2026-10-20T06:42:08Z

SanzSkuy: Created page with "Catatan tentang cara deploy aplikasi (Python FastAPI, Rust Actix, Node frontend) langsung di server Ubuntu (contoh: <code>marshall-3</code>) tanpa Docker, memakai '''uv''', '''systemd''', dan '''Ansible'''. Fokus utama catatan ini adalah sisi '''sysadmin''': layout direktori, model user dan permission, hardening service, dan otomasi. == Gambaran besar == Docker memberi tiga hal: '''isolasi''', '''reproducibility''', dan '''packaging'''. Di bare metal, ketiganya tetap b..."

Catatan tentang cara deploy aplikasi (Python FastAPI, Rust Actix, Node frontend) langsung di server Ubuntu (contoh: <code>marshall-3</code>) tanpa Docker, memakai '''uv''', '''systemd''', dan '''Ansible'''. Fokus utama catatan ini adalah sisi '''sysadmin''': layout direktori, model user dan permission, hardening service, dan otomasi.

== Gambaran besar ==

Docker memberi tiga hal: '''isolasi''', '''reproducibility''', dan '''packaging'''. Di bare metal, ketiganya tetap bisa didapat dengan alat bawaan Linux:

{| class="wikitable"
! Kebutuhan !! Di Docker !! Di bare metal
|-
| Isolasi proses || namespace, cgroup || user terpisah per app + hardening systemd (juga pakai namespace & cgroup)
|-
| Dependency terkunci || image || lock file (<code>uv.lock</code>, <code>Cargo.lock</code>, <code>package-lock.json</code>) + venv per release
|-
| Restart otomatis || <code>restart: unless-stopped</code> || <code>Restart=on-failure</code> di unit systemd
|-
| Log || <code>docker logs</code> || <code>journalctl -u nama-app</code>
|-
| Rollback || tag image lama || folder release lama + symlink
|-
| Deploy berulang || compose / CI || Ansible
|}

'''Kapan bare metal masuk akal:''' sedikit server, workload GPU, tim kecil, atau binary tunggal (Rust/Go).
'''Kapan Docker lebih unggul:''' banyak server, scaling horizontal, atau dependency sistem yang bentrok antar app (misalnya versi CUDA berbeda per app, karena di bare metal semua app berbagi satu driver NVIDIA).

== Layout direktori (FHS) ==

Setiap app memakai lokasi standar ''Filesystem Hierarchy Standard'', supaya jelas mana kode, mana config, mana data:

{| class="wikitable"
! Path !! Isi !! Kenapa di sini
|-
| <code>/opt/<app>/releases/<versi>/</code> || kode + <code>.venv</code> / <code>target</code> / <code>dist</code> || <code>/opt</code> untuk software tambahan yang bukan dari paket OS
|-
| <code>/opt/<app>/current</code> || symlink ke release aktif || service selalu menunjuk ke sini; ganti versi = ganti symlink
|-
| <code>/etc/<app>/<app>.env</code> || environment variable & secret || <code>/etc</code> untuk konfigurasi milik host, terpisah dari kode
|-
| <code>/var/lib/<app>/</code> || data, cache model, upload, cache uv/cargo/npm || <code>/var/lib</code> untuk state yang ditulis aplikasi saat jalan
|-
| <code>/opt/uv/python/</code> || interpreter Python bersama || dipakai semua app, bukan milik satu user
|-
| <code>/etc/systemd/system/<app>.service</code> || unit service || lokasi unit buatan admin (bukan dari paket)
|}

Pemisahan ini penting untuk permission: '''kode''' boleh read-only saat runtime, '''config''' hanya root yang boleh ubah, dan '''hanya folder data''' yang boleh ditulis aplikasi.

== Model user & permission ==

=== Satu app, satu system user ===

<syntaxhighlight lang="bash">
sudo useradd --system --home-dir /var/lib/transcribe-api \
--shell /usr/sbin/nologin transcribe
</syntaxhighlight>

* <code>--system</code>: UID diambil dari rentang system (di Ubuntu di bawah 1000), tidak muncul di layar login, dan tidak dibuatkan mailbox atau aging password.
* <code>--shell /usr/sbin/nologin</code>: user tidak bisa login interaktif. Kalau proses app dibobol, penyerang tidak otomatis dapat shell login.
* '''Kenapa per app?''' Kalau satu app bocor, app lain dan file-nya tidak ikut terbaca. Ini prinsip ''least privilege''.

Perintah berguna:
<syntaxhighlight lang="bash">
id transcribe # UID, GID, dan group tambahan
getent passwd transcribe # home & shell
getent group | grep transcribe
sudo -u transcribe -H bash -c 'whoami; echo $HOME' # tes sebagai user app
</syntaxhighlight>

'''Salah nama user?''' Rename tanpa bikin ulang:
<syntaxhighlight lang="bash">
sudo usermod -l transcribe -d /var/lib/transcribe-api appuser # ganti login & home
sudo groupmod -n transcribe appuser # ganti nama group
</syntaxhighlight>
Karena UID/GID tidak berubah, ownership file otomatis ikut. <code>usermod -d</code> akan gagal kalau user sedang dipakai proses yang jalan, jadi stop service-nya dulu.

Error <code>chown: invalid group: 'root:appuser'</code> artinya group tersebut sudah tidak ada (sudah di-rename atau dihapus). Cek dengan <code>getent group</code>.

=== Tabel ownership & mode ===

{| class="wikitable"
! Path !! Owner:Group !! Mode !! Artinya
|-
| <code>/opt/<app></code> || root:root || <code>0755</code> || hanya root yang bisa membuat/mengganti symlink <code>current</code>
|-
| <code>/opt/<app>/releases</code> || app:app || <code>0755</code> || user app meng-clone dan build release di sini
|-
| <code>/etc/<app></code> || root:app || <code>0750</code> || app boleh masuk & baca, user lain tidak bisa melihat isinya
|-
| <code>/etc/<app>/<app>.env</code> || root:app || <code>0640</code> || root tulis, app baca, lainnya tidak bisa apa-apa
|-
| <code>/var/lib/<app></code> || app:app || <code>0750</code> || satu-satunya tempat app boleh menulis
|-
| <code>/var/lib/<app>/.ssh</code> || app:app || <code>0700</code> || deploy key; SSH menolak key yang permission-nya terlalu terbuka
|-
| <code>/opt/uv/python</code> || root:root || <code>a+rX</code> || semua user boleh baca & eksekusi interpreter, tidak boleh ubah
|}

=== Membaca mode oktal ===

Tiap digit = '''owner''', '''group''', '''others'''. Nilainya jumlah dari <code>r=4</code>, <code>w=2</code>, <code>x=1</code>.

{| class="wikitable"
! Mode !! Owner !! Group !! Others !! Dipakai untuk
|-
| <code>0755</code> || rwx || r-x || r-x || folder publik, binary
|-
| <code>0750</code> || rwx || r-x || --- || folder privat yang boleh dibaca group
|-
| <code>0700</code> || rwx || --- || --- || folder sangat privat (<code>.ssh</code>)
|-
| <code>0640</code> || rw- || r-- || --- || file secret yang dibaca group
|-
| <code>0600</code> || rw- || --- || --- || private key
|}

Untuk '''folder''', bit <code>x</code> artinya "boleh masuk (traverse)", bukan "eksekusi". Tanpa <code>x</code> di folder induk, file di dalamnya tidak bisa diakses walaupun file-nya sendiri <code>r</code>.

<code>chmod -R a+rX</code> (huruf X besar) memberi <code>x</code> hanya ke folder dan file yang sudah executable. Ini cara aman membuka akses baca satu pohon direktori tanpa membuat semua file teks jadi executable.

=== Kenapa env file <code>root:app 0640</code>? ===

* App perlu '''membaca''' secret (DATABASE_URL, SECRET_KEY), tapi tidak perlu '''mengubahnya'''.
* Kalau app dibobol, penyerang tidak bisa mengganti config agar persisten.
* User lain di server tidak bisa membaca secret sama sekali.
* Jangan simpan secret di <code>.env</code> dalam folder kode: gampang ikut ter-commit, dan ikut terbaca siapa pun yang bisa membaca kode.

=== Toolchain bersama & masalah home directory ===

uv bisa meng-install Python sendiri. Defaultnya ke <code>~/.local/share/uv/python</code>. Masalahnya:

* venv '''hanya symlink''' ke interpreter. Kalau interpreter ada di home user A, user B tidak bisa memakainya.
* Unit systemd dengan <code>ProtectHome=true</code> membuat <code>/home</code>, <code>/root</code>, dan <code>/run/user</code> tidak terlihat. Interpreter di home = service gagal start.

Solusinya taruh di lokasi bersama dan buka akses baca:
<syntaxhighlight lang="bash">
export UV_PYTHON_INSTALL_DIR=/opt/uv/python
sudo -E uv python install 3.13
sudo chmod -R a+rX /opt/uv/python
</syntaxhighlight>

Pola yang sama untuk Rust: <code>RUSTUP_HOME=/opt/rust/rustup</code>, <code>CARGO_HOME=/opt/rust/cargo</code>, lalu <code>a+rX</code>. Cache per app (registry cargo, cache uv, cache npm) ditaruh di <code>/var/lib/<app></code> yang memang writable.

=== Akses GPU ===

Device NVIDIA ada di <code>/dev/nvidia*</code>:
<syntaxhighlight lang="bash">
ls -l /dev/nvidia*
</syntaxhighlight>
Kalau mode-nya <code>crw-rw-rw-</code>, semua user bisa memakai GPU. Kalau hanya group <code>video</code>/<code>render</code>, tambahkan user app ke group tersebut (<code>usermod -aG video transcribe</code>) dan tulis <code>SupplementaryGroups=video</code> di unit. Opsi <code>-a</code> wajib; tanpa itu, group tambahan lain akan terhapus.

=== sudo yang sempit ===

Kalau deploy dijalankan sebagai user app dan perlu restart service, beri izin '''hanya''' untuk perintah itu:

<syntaxhighlight lang="bash">
echo 'transcribe ALL=(root) NOPASSWD: /usr/bin/systemctl restart transcribe-api, /usr/bin/systemctl restart transcribe-api-worker' \
| sudo tee /etc/sudoers.d/transcribe-api
sudo chmod 0440 /etc/sudoers.d/transcribe-api
sudo visudo -cf /etc/sudoers.d/transcribe-api # validasi sintaks!
</syntaxhighlight>

* Selalu validasi dengan <code>visudo -c</code>. File sudoers yang rusak bisa mengunci <code>sudo</code> untuk semua orang.
* Path harus absolut dan persis sama. Di Ubuntu modern <code>/bin</code> adalah symlink ke <code>/usr/bin</code>, tapi sudo membandingkan string path, jadi cek dengan <code>command -v systemctl</code>.
* Jangan beri <code>NOPASSWD: ALL</code> ke user app. Itu sama saja memberi root.

Kalau deploy dijalankan lewat Ansible dengan user admin + <code>become</code>, aturan sudoers untuk user app '''tidak diperlukan sama sekali'''.

=== Siapa yang boleh menulis kode? ===

Di setup ini user app yang meng-clone dan build release, jadi kode bisa ditulis oleh user app. Ini sederhana tapi berarti app yang dibobol bisa mengubah kodenya sendiri. Alternatif yang lebih ketat:

* Buat user <code>deployer</code> terpisah yang meng-clone & build semua release.
* User app hanya punya akses baca + eksekusi ke <code>/opt/<app></code>.
* Bonus: cache uv bisa dipakai bersama antar app, sehingga hardlink menghemat disk (berguna untuk paket besar seperti torch).

Pada level ini, <code>ProtectSystem=strict</code> sudah menahan sebagian besar risiko: saat runtime seluruh filesystem read-only bagi proses app, kecuali <code>ReadWritePaths</code>.

== systemd ==

=== Anatomi unit ===

<syntaxhighlight lang="ini">
[Unit]
Description=Transcribe API
After=network-online.target redis-server.service
Wants=network-online.target redis-server.service

[Service]
Type=simple
User=transcribe
Group=transcribe
SupplementaryGroups=video
WorkingDirectory=/opt/transcribe-api/current
Environment=HOME=/var/lib/transcribe-api
Environment=PORT=6969
EnvironmentFile=-/etc/transcribe-api/transcribe-api.env
ExecStart=/opt/transcribe-api/current/.venv/bin/python -m uvicorn main:app --host 127.0.0.1 --port 6969
Restart=on-failure
RestartSec=5

NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true
ReadWritePaths=/var/lib/transcribe-api

[Install]
WantedBy=multi-user.target
</syntaxhighlight>

Catatan per baris:
* <code>After=</code> mengatur '''urutan''', <code>Wants=</code>/<code>Requires=</code> mengatur '''ketergantungan'''. Hanya <code>After=</code> tidak membuat Redis ikut dijalankan.
* <code>EnvironmentFile=-...</code>: tanda <code>-</code> artinya "jangan gagal kalau file tidak ada". Variabel dari file '''meng-override''' <code>Environment=</code>.
* Format env file systemd: <code>KEY=value</code> per baris, '''tanpa''' <code>export</code>.
* <code>ExecStart</code> harus path absolut. Panggil binary venv langsung, bukan <code>uv run</code>, karena <code>uv run</code> bisa mencoba sync dependency saat start.
* Worker sebaiknya <code>Restart=always</code> dan <code>TimeoutStopSec=120</code> supaya job yang sedang jalan sempat selesai saat restart (systemd mengirim SIGTERM dulu, baru SIGKILL setelah timeout).

=== Directive hardening ===

{| class="wikitable"
! Directive !! Efek
|-
| <code>NoNewPrivileges=true</code> || proses dan turunannya tidak bisa naik hak akses (setuid, file capabilities tidak berlaku)
|-
| <code>ProtectSystem=strict</code> || seluruh filesystem read-only bagi service
|-
| <code>ReadWritePaths=</code> || pengecualian: path yang tetap boleh ditulis
|-
| <code>ProtectHome=true</code> || <code>/home</code>, <code>/root</code>, <code>/run/user</code> tidak terlihat
|-
| <code>PrivateTmp=true</code> || <code>/tmp</code> privat per service, tidak berbagi dengan proses lain
|}

Ukur tingkat keamanan unit:
<syntaxhighlight lang="bash">
systemd-analyze security transcribe-api
</syntaxhighlight>
Output-nya memberi skor dan daftar directive lain yang bisa ditambahkan (misalnya <code>ProtectKernelTunables</code>, <code>RestrictAddressFamilies</code>). Tambahkan bertahap dan tes, karena hardening yang terlalu ketat bisa mematahkan app (misalnya akses GPU butuh device yang tidak diblokir <code>PrivateDevices</code>).

=== Operasional harian ===

<syntaxhighlight lang="bash">
sudo systemctl daemon-reload # wajib setelah edit file unit
sudo systemctl enable --now transcribe-api # aktif saat boot + jalan sekarang
systemctl status transcribe-api transcribe-api-worker
journalctl -u transcribe-api -u transcribe-api-worker -f # follow log
journalctl -u transcribe-api --since "1 hour ago" -p err # hanya error
systemctl cat transcribe-api # lihat unit final yang dipakai
</syntaxhighlight>

=== Exit code systemd yang sering muncul ===

{| class="wikitable"
! Status !! Penyebab umum
|-
| <code>status=203/EXEC</code> || path di <code>ExecStart</code> salah, file tidak executable, atau venv rusak (interpreter yang di-symlink tidak bisa diakses)
|-
| <code>status=217/USER</code> || user di <code>User=</code> tidak ada
|-
| <code>status=200/CHDIR</code> || <code>WorkingDirectory</code> tidak ada atau tidak bisa dimasuki user app
|-
| <code>status=226/NAMESPACE</code> || path di <code>ReadWritePaths</code> belum dibuat
|-
| <code>Permission denied</code> di log app || app menulis di luar <code>ReadWritePaths</code> (cache model, file upload); arahkan ke <code>/var/lib/<app></code>
|}

== Pola release + symlink ==

<pre>
/opt/transcribe-api/
├── releases/
│ ├── 3f2a9c1d7e0b/
│ └── 9be41c0a22f1/
└── current -> releases/3f2a9c1d7e0b
</pre>

Alur deploy:
# Clone versi baru ke <code>releases/<sha></code>.
# Build (<code>uv sync --locked --no-dev</code>, <code>cargo build --release --locked</code>, <code>npm ci && npm run build</code>).
# Jalankan migrasi database kalau ada.
# Arahkan <code>current</code> ke release baru, restart service.
# Health check. Gagal → arahkan kembali ke release lama.

'''Soal atomik:''' <code>ln -sfn</code> sebenarnya menghapus symlink lalu membuat ulang, sehingga ada jeda sangat singkat tanpa <code>current</code>. Cara yang benar-benar atomik:
<syntaxhighlight lang="bash">
ln -s /opt/app/releases/NEW /opt/app/current.tmp
mv -T /opt/app/current.tmp /opt/app/current # rename(2) atomik
</syntaxhighlight>

'''Venv tidak bisa dipindah.''' Path absolut tertanam di script dalam <code>.venv/bin</code>, jadi selalu build venv langsung di folder release, jangan build di tempat lain lalu di-copy.

== Python dengan uv ==

* <code>uv sync --locked</code> gagal kalau <code>uv.lock</code> tidak sinkron dengan <code>pyproject.toml</code>. Ini yang diinginkan di produksi: server tidak pernah mengubah lock file.
* <code>--no-dev</code> melewati dependency development/test.
* <code>UV_PYTHON_DOWNLOADS=never</code> mencegah uv diam-diam mengunduh Python saat build.
* Update dependency dilakukan di laptop: <code>uv lock --upgrade</code>, commit, lalu deploy.
* Cache uv memakai hardlink ke venv selama berada di filesystem yang sama, sehingga deploy berikutnya cepat dan hemat disk.

== Redis lokal ==

<syntaxhighlight lang="bash">
sudo apt install -y redis-server
sudo sed -i 's/^appendonly no/appendonly yes/' /etc/redis/redis.conf # persistence
grep -E '^(bind|appendonly)' /etc/redis/redis.conf # bind 127.0.0.1 -::1
sudo systemctl enable --now redis-server
redis-cli ping
</syntaxhighlight>
Redis tanpa password '''wajib''' hanya listen di localhost. Di Docker, hostname-nya <code>redis</code>; di bare metal jadi <code>redis://127.0.0.1:6379/0</code>.

== Jaringan ==

* <code>--host 127.0.0.1</code>: app hanya bisa diakses dari server itu sendiri (cocok kalau nginx ada di server yang sama).
* <code>--host 0.0.0.0</code>: app bisa diakses dari luar. Wajib dibarengi firewall.
* Kalau nginx publik ada di VM proxy terpisah, buka port app '''hanya untuk IP VM proxy''':

<syntaxhighlight lang="bash">
sudo ufw allow OpenSSH
sudo ufw allow from 192.168.88.10 to any port 6969 proto tcp comment 'transcribe-api'
sudo ufw enable
sudo ufw status numbered
</syntaxhighlight>

Ubuntu memakai '''AppArmor''', bukan SELinux seperti AlmaLinux/RHEL. Untuk app di <code>/opt</code> biasanya tidak perlu konfigurasi tambahan.

== Otomasi dengan Ansible ==

=== Kenapa Ansible ===
* '''Agentless''': cukup SSH + Python di server.
* '''Idempotent''': dijalankan berkali-kali hasilnya sama; hanya yang berubah yang diubah.
* Semua langkah manual di atas terdokumentasi sebagai kode, sehingga server bisa dibangun ulang kapan saja.

=== Struktur project ===

<pre>
ansible-apps/
├── inventory.ini daftar server
├── apps.yml daftar app (repo, port, worker)
├── deploy.yml playbook utama
├── group_vars/all/main.yml setting global
├── group_vars/all/vault.yml secret terenkripsi
├── scripts/new-app.sh tambah app interaktif
└── roles/
├── base/ paket dasar
├── redis/
├── python_toolchain/ uv + Python di /opt/uv/python
├── rust_toolchain/ rustup di /opt/rust
├── node_toolchain/ NodeSource
└── app/ clone, deteksi tipe, build, systemd/nginx, health check, rollback
</pre>

=== Entry app ===

<syntaxhighlight lang="yaml">
apps:
- name: transcribe-api
repo: git@github.com:org/transcribe-api.git
version: main
port: 6969
user: transcribe
worker: true # bikin service transcribe-api-worker
redis: true
apt_packages: [ffmpeg]
extra_groups: [video]
health_path: /health
</syntaxhighlight>

Tipe app dideteksi dari isi repo: <code>pyproject.toml</code> → Python, <code>Cargo.toml</code> → Rust, <code>package.json</code> → Node (Vite/React jadi static di-serve nginx, Next/Nuxt jadi service).

=== Perintah ===

<syntaxhighlight lang="bash">
ansible-playbook deploy.yml # semua app
ansible-playbook deploy.yml -e only=transcribe-api # satu app
ansible-playbook deploy.yml -e only=core-api -e rev=v1.2.0 # versi tertentu / rollback
ansible-playbook deploy.yml --syntax-check
ansible-vault encrypt group_vars/all/vault.yml
</syntaxhighlight>

=== Konsep Ansible yang terkait permission ===

* <code>become: true</code>: task dijalankan sebagai root lewat sudo.
* <code>become_user: transcribe</code>: task dijalankan sebagai user app (clone, build), sehingga file yang dihasilkan langsung dimiliki user yang benar tanpa <code>chown</code> belakangan.
* Paket <code>acl</code> wajib terpasang. Saat <code>become_user</code> ke user non-root, Ansible menulis file modul sementara lalu memakai ACL (<code>setfacl</code>) agar user tujuan bisa membacanya.
* Modul <code>file</code> dengan <code>owner</code>, <code>group</code>, <code>mode</code> menggantikan rangkaian <code>mkdir</code>/<code>chown</code>/<code>chmod</code> dan idempotent.
* Secret di '''ansible-vault''', dirender ke env file lewat modul <code>template</code> dengan mode <code>0640</code>.

=== Deploy key untuk repo private ===

* Satu key per app, disimpan di <code>/var/lib/<app>/.ssh/id_ed25519</code> (mode <code>0600</code>, folder <code>0700</code>).
* Didaftarkan sebagai '''Deploy Key read-only''' di repo. Kalau server bocor, yang terekspos hanya akses baca ke satu repo, bukan akun GitHub pribadi.
* <code>StrictHostKeyChecking=accept-new</code>: host key disimpan saat pertama kali, dan koneksi ditolak kalau host key berubah (proteksi MITM).

== Troubleshooting ==

{| class="wikitable"
! Gejala !! Penyebab !! Solusi
|-
| <code>chown: invalid group</code> || group sudah di-rename/dihapus || <code>getent group</code>, pakai nama baru
|-
| <code>useradd</code> menghasilkan shell aneh || sisa <code>\</code> line-continuation ikut diketik dalam satu baris || cek <code>getent passwd</code>, bikin ulang user
|-
| Service <code>203/EXEC</code> padahal file ada || venv menunjuk ke Python di home user lain || install Python di <code>/opt/uv/python</code>, buat ulang venv
|-
| Model Whisper gagal diunduh || cache di luar <code>ReadWritePaths</code> || set <code>WHISPER_CACHE_DIR</code> / <code>HF_HOME</code> ke <code>/var/lib/<app></code>
|-
| <code>libcudnn</code> / <code>libcublas</code> not found || di Docker library datang dari image || install paket pip <code>nvidia-cudnn-cu12</code> / <code>nvidia-cublas-cu12</code> atau CUDA toolkit di host
|-
| Worker restart terus || error di job pertama atau Redis belum jalan || <code>journalctl -u app-worker -n 100</code>, <code>redis-cli ping</code>
|-
| Ansible gagal <code>become_user</code> || paket <code>acl</code> belum terpasang || <code>apt install acl</code>
|}

== Checklist server baru ==

* [ ] User admin pakai SSH key, login password dimatikan
* [ ] <code>ufw</code> aktif, hanya SSH + port yang perlu
* [ ] Driver NVIDIA terpasang, <code>nvidia-smi</code> jalan (kalau ada GPU)
* [ ] <code>unattended-upgrades</code> aktif untuk patch keamanan
* [ ] Jalankan <code>ansible-playbook deploy.yml</code>
* [ ] <code>systemd-analyze security <app></code> untuk tiap service
* [ ] Backup data di <code>/var/lib/<app></code> dan database, '''tes restore'''

== Lihat juga ==
* [https://docs.astral.sh/uv/ Dokumentasi uv]
* [https://www.freedesktop.org/software/systemd/man/latest/systemd.exec.html systemd.exec (directive hardening)]
* [https://refspecs.linuxfoundation.org/FHS_3.0/fhs/index.html Filesystem Hierarchy Standard 3.0]
* [https://docs.ansible.com/ Dokumentasi Ansible]

DevOps

2026-10-20T06:41:50Z

SanzSkuy:

* [[Setup Jenkins]]
* [[Docker Registry & Rootless Docker]]
* [[Elasticsearch]]
* [[Postgres master & slave]]
* [[Cara buat monitoring server pake Grafana & Prometheus]]
* [[Deploy app bare-metal]]

== Microk8s ==
* [[Microk8s: setup awal]]
* [[Microk8s: setup registry]]

Main Page

2026-10-19T01:47:44Z

SanzSkuy:

'''Haidhi Angkawijana Tedja''' 
Software Engineer @ Telkom Indonesia

I write everything that I learn

[https://github.com/haidhiSkuy GitHub] • [https://www.linkedin.com/in/haidhi-angkawijana-tedja/ LinkedIn] • haidhiangkawijana@gmail.com

== Research Interests ==
* Heterogeneous Computing
* High-Performance Computing (HPC)
* GPU/Accelerator Architectures
* Edge Computing
* Hardware-Software Co-design for AI Systems

== Education ==
=== South Tangerang Institute of Technology (ITTS) ===
''2021 – 2025''
* B.Sc. in Computer Science
* Undergraduate Thesis: "Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization"
* Advised by [https://id.wikipedia.org/wiki/Onno_W._Purbo Onno W. Purbo]

=== Riyadhussholihiin Islamic Boarding School ===
''2016 - 2021''
* Language Class (Arabic)
* Organisasi Santri Riyadhussholihin (OSRIY) & Baitul Qur'an
* Grade: Mumtaz (excellent)

== Work Experience ==
* Telkom Indonesia — AI & Backend Engineer ''(July 2024 – Present)''
* Meister Sinergi Indonesia (AERY) — ML/AI Engineer ''(October 2023 – Present)''
* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''
* Riyadhussholihiin Islamic Boarding School, Pandeglang — Teacher ''(July 2020 - July 2021)''

== Publication ==
* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608

== CV ==
* [https://drive.google.com/file/d/1y4H7s0E_N3XzCqi9o1iVPRj-KdLHOlEJ/view?usp=sharing CV_Haidhi_Angkawijana_Tedja.pdf]

== Categories ==
* [[Daftar Isi AI/ML|Artificial Intelligence, Machine Learning, & Data Science]]
* [[Daftar Isi Cybersecurity|Cybersecurity]]
* [[Linux & Operating System]]
* [[DevOps]]
* [[Web Assembly]]
* [[High-performance computing]]
* [[Programming, Software Engineering, etc]]

 
<pre>
Imam Syafi'i رحمه الله:

الْعِلْمُ صَيْدٌ وَالْكِتَابَةُ قَيْدُهُ * قَيِّدْ صُيُوْدَكَ بِالْحِبَالِ الْوَاثِقَهْ
فَمِنَ الْحَمَاقَةِ أَنْ تَصِيْدَ غَزَالَةً وَتَتْرُكَهَا بَيْنَ الْخَلاَئِقِ طَالِقَهْ

Knowledge is a quarry, and the written word its chain.
Bind thy quarry fast with cords unyielding.
For folly it is to hunt the stag,
Only to loose it once more among the wilds.
</pre>

SRAM & DRAM

2026-10-12T04:01:04Z

SanzSkuy: Created page with "== Pendahuluan == Pada model sederhana, sistem komputer terdiri dari '''CPU''' dan '''memory system''' yang berupa array linear byte, dengan waktu akses konstan untuk setiap lokasi. Model ini efektif sampai batas tertentu, tetapi '''tidak mencerminkan cara kerja sistem modern'''. Dalam praktiknya, memory system adalah '''hierarki perangkat penyimpanan''' dengan kapasitas, biaya, dan waktu akses yang berbeda-beda. === Level hierarki (atas ke bawah) === # '''Register C..."

== Pendahuluan ==

Pada model sederhana, sistem komputer terdiri dari '''CPU''' dan '''memory system''' yang berupa array linear byte, dengan waktu akses konstan untuk setiap lokasi. Model ini efektif sampai batas tertentu, tetapi '''tidak mencerminkan cara kerja sistem modern'''.

Dalam praktiknya, memory system adalah '''hierarki perangkat penyimpanan''' dengan kapasitas, biaya, dan waktu akses yang berbeda-beda.

=== Level hierarki (atas ke bawah) ===

# '''Register CPU''': menyimpan data yang paling sering dipakai
# '''Cache memory (SRAM)''': kecil dan cepat, menjadi ''staging area'' untuk subset data/instruksi di main memory
# '''Main memory (DRAM)''': lebih besar tetapi lambat, menjadi staging area untuk data di disk
# '''Disk''': sangat besar dan sangat lambat, bisa menjadi staging area untuk data di disk/tape mesin lain lewat jaringan

Semakin ke bawah: '''makin besar, makin murah per bit, makin lambat'''.

=== Kenapa hierarki ini bekerja? ===

Program yang ditulis dengan baik cenderung mengakses level atas lebih sering daripada level di bawahnya. Akibatnya level bawah boleh lambat (sehingga besar dan murah). Efek akhirnya: '''kapasitas dan biaya seperti storage paling bawah, tetapi kecepatan seperti storage paling atas'''.

=== Waktu akses ===

{| class="wikitable"
! Lokasi data !! Waktu akses
|-
| Register || 0 cycle
|-
| Cache || 4 sampai 75 cycle
|-
| Main memory || ratusan cycle
|-
| Disk || puluhan juta cycle
|}

=== Locality ===

Ide sentral bab ini. Program dengan '''good locality''':
* mengakses data yang '''sama''' berulang-ulang ('''temporal locality'''), atau
* mengakses data yang '''berdekatan''' ('''spatial locality''')

Program dengan locality bagus lebih banyak dilayani level atas, sehingga lebih cepat. Contoh: pada sistem Core i7, beberapa kernel perkalian matriks dengan jumlah operasi aritmetika yang sama bisa berbeda kecepatan hampir '''40x''' hanya karena locality-nya.

=== Roadmap bab ===

* Teknologi penyimpanan dasar: SRAM, DRAM, ROM, rotating disk, SSD
* Organisasi menjadi hierarki, dengan fokus pada '''cache''' (paling berdampak ke performa aplikasi)
* Menganalisis dan memperbaiki locality program C
* '''Memory mountain''': karakterisasi performa hierarki memori sebagai fungsi dari locality

== 6.1 Storage Technologies ==

Kemajuan teknologi komputer sangat dipengaruhi kemajuan teknologi storage. IBM PC-XT (1982) memiliki disk 10 MB. Pada 2015, mesin tipikal punya kapasitas disk sekitar 300.000x lebih besar, dan kapasitas naik 2x tiap dua tahun.

=== 6.1.1 Random Access Memory (RAM) ===

RAM terdiri dari dua varian:

* '''SRAM''' (Static RAM): lebih cepat dan jauh lebih mahal. Dipakai untuk '''cache memory''' (di dalam maupun di luar chip CPU).
* '''DRAM''' (Dynamic RAM): lebih lambat dan murah. Dipakai untuk '''main memory''' dan '''frame buffer''' sistem grafis.

==== Static RAM (SRAM) ====

* Menyimpan tiap bit dalam sel '''bistable''' yang terdiri dari '''6 transistor'''.
* Sirkuit punya dua konfigurasi tegangan stabil (dua ''state''). State lain bersifat tidak stabil dan akan bergerak cepat ke salah satu state stabil.
* Analogi: '''inverted pendulum''' (pendulum terbalik)
** Miring penuh ke kiri: stabil
** Miring penuh ke kanan: stabil
** Tegak lurus: '''metastable'''. Secara teori bisa bertahan, tetapi gangguan sekecil apa pun membuatnya jatuh dan tidak kembali ke posisi tegak.
* Selama ada daya (power), nilai SRAM bertahan tanpa batas. Gangguan seperti noise listrik akan hilang dengan sendirinya: sirkuit kembali ke nilai stabil.

==== Perbandingan SRAM vs DRAM (Figure 6.2) ====

{| class="wikitable"
! !! Transistor per bit !! Waktu akses relatif !! Persistent? !! Sensitive? !! Biaya relatif !! Pemakaian
|-
| '''SRAM''' || 6 || 1x || Ya || Tidak || 1.000x || Cache memory
|-
| '''DRAM''' || 1 || 10x || Tidak || Ya || 1x || Main memory, frame buffer
|}

Catatan istilah:
* '''Biaya''' = biaya per bit penyimpanan. Sebagian besar ditentukan oleh luas area silikon, sehingga SRAM (6 transistor/bit) jauh lebih mahal daripada DRAM (1 transistor/bit).
* '''Persistent''' = nilai bertahan selama chip dialiri daya, tanpa perlu di-refresh. Bukan berarti data bertahan saat listrik mati (SRAM dan DRAM keduanya ''volatile'').
* '''Sensitive''' = rentan terhadap gangguan (noise). DRAM menyimpan bit sebagai muatan di kapasitor yang bocor pelan-pelan, sehingga perlu di-refresh berkala.

==== Conventional DRAMs ====

Sel (bit) dalam chip DRAM dibagi menjadi '''d supercell''', masing-masing terdiri dari '''w sel DRAM'''.

* Chip '''d × w''' menyimpan total '''d·w bit'''.
* Supercell disusun sebagai array persegi panjang dengan '''r baris''' dan '''c kolom''', dengan '''r·c = d'''.
* Alamat supercell berbentuk '''(i, j)''': i = baris, j = kolom.

''Catatan terminologi'': komunitas storage tidak punya nama baku untuk elemen array DRAM. Arsitek komputer menyebutnya "cell", perancang sirkuit menyebutnya "word". Buku ini memakai istilah netral '''supercell'''.

===== Contoh: DRAM 16 × 8 (Figure 6.3) =====

* d = 16 supercell, w = 8 bit per supercell, total '''128 bit'''
* r = 4 baris, c = 4 kolom
* Supercell berwarna pada alamat '''(2, 1)'''

Informasi keluar-masuk chip lewat '''pin''' (konektor eksternal), dan tiap pin membawa sinyal 1 bit:
* '''Pin data''': 8 pin, mentransfer 1 byte sekaligus
* '''Pin addr''': 2 pin, membawa alamat baris atau kolom (2 bit)
* (Pin kontrol tidak ditampilkan)

Chip DRAM dihubungkan ke '''memory controller''', yaitu sirkuit yang dapat mentransfer w bit sekaligus ke/dari chip, lalu terhubung ke CPU.

===== Membaca supercell (i, j) =====

Dilakukan dalam dua langkah (Figure 6.4):

# '''RAS (Row Access Strobe)''': controller mengirim alamat baris '''i'''. DRAM menyalin '''seluruh isi baris i''' ke '''internal row buffer'''.
# '''CAS (Column Access Strobe)''': controller mengirim alamat kolom '''j'''. DRAM mengambil supercell (i, j) dari row buffer, lalu mengirim w bit-nya ke controller.

RAS dan CAS '''berbagi pin addr yang sama''', sehingga alamat harus dikirim berurutan.

Contoh membaca supercell (2, 1) pada chip 16 × 8:
# Controller kirim '''RAS = 2''', maka seluruh baris 2 disalin ke row buffer
# Controller kirim '''CAS = 1''', maka 8 bit di supercell (2, 1) dikirim ke controller

===== Internal row buffer =====

Penyimpanan kecil di dalam chip DRAM yang muat '''satu baris penuh''' supercell. Fungsinya sebagai tempat penampung baris yang sedang diakses. Supercell yang diminta dipilih dari row buffer, bukan langsung dari array utama.

===== Kenapa array 2D, bukan linear? =====

* '''Keuntungan''': jumlah pin addr berkurang. Contoh: 16 supercell linear (alamat 0 sampai 15) butuh 4 pin addr, sedangkan susunan 4 × 4 cukup 2 pin.
* '''Kerugian''': alamat dikirim dalam dua tahap (RAS lalu CAS), sehingga '''waktu akses bertambah'''.

== Rumus Ringkas ==

{| class="wikitable"
! Yang ditanya !! Rumus
|-
| Total bit || d × w
|-
| Jumlah pin data || w
|-
| Jumlah pin addr || log2(max(r, c))
|-
| Supercell disalin saat RAS || c (satu baris penuh)
|-
| Ukuran row buffer || c × w bit
|}

== Contoh Soal ==

=== Contoh 1: DRAM 64 × 4 (8 baris × 8 kolom) ===

* Total bit = 64 × 4 = '''256 bit'''
* Pin data = '''4'''
* Pin addr: 8 baris butuh 3 bit, maka '''3 pin'''
* Baca (5, 3): RAS = 5 (baris 5 ke row buffer), lalu CAS = 3 (kirim 4 bit)

=== Contoh 2: DRAM 256 × 8 (16 × 16) ===

* Total bit = 256 × 8 = '''2048 bit'''
* Pin data = '''8'''
* Pin addr = log216 = '''4 pin''' (jika linear: log2256 = 8 pin)

=== Contoh 3: DRAM 64 × 16 (8 × 8) ===

* Total bit = '''1024 bit'''
* Pin data = '''16''' (ditentukan oleh w, bukan selalu 8)
* Pin addr = '''3'''
* Baca (6, 2): RAS = 6 (8 supercell masuk row buffer), lalu CAS = 2 (kirim 16 bit)

=== Contoh 4: DRAM 128 × 4 (16 baris × 8 kolom) ===

* Total bit = '''512 bit'''
* Pin data = '''4'''
* Pin addr = '''4''' (baris butuh 4 bit, kolom butuh 3 bit, ambil yang terbesar karena pin dibagi)
* Supercell disalin saat RAS = '''8''' (row buffer = 8 × 4 = 32 bit)

== Poin Penting ==

* Hierarki memori bekerja karena '''locality'''.
* SRAM: cepat, stabil, mahal, untuk cache. DRAM: lambat, sensitif, murah, untuk main memory.
* Pin data ditentukan oleh '''w''', pin addr ditentukan oleh '''dimensi terbesar''' array.
* Pembacaan DRAM: '''RAS (baris ke row buffer) lalu CAS (kolom dari row buffer)'''.

Linux & Operating System

2026-10-12T04:00:49Z

SanzSkuy:

== Linux ==
* [[Cara install Arch Linux]]
* [[Linux from Scratch]]
* [[Install Arch Linux ARM di QEMU]]
* [[Bluetooth di Arch Linux (Pairing TWS)]]
* [[CUE 1.0]]

== Computer Systems ==
* [[Cara Kerja Floating Point]]
* [[Introduction to Assembly|Assembly Course]]
* [[Tahap-tahap dari source code menjadi executable file]]
* [[OS Manages Hardware]]
* [[Concurrency & Parallelism]]
* [[Unsigned Encodings]]

=== Representing and Manipulating Information ===
* [[CS:APP 2 Intro]]
* [[Accessing Information]]

=== temp ===
* [[Intro Compiler & Machine Abstraction]]
* [[SRAM & DRAM]]

== gem5 ==
* [[gem5: hello world]]

== LLVM ==
* [[llvm: cara install]]

Gem5: hello world

2026-10-11T08:43:05Z

SanzSkuy: Created page with "'''gem5''' adalah simulator arsitektur komputer open-source yang dipakai untuk riset dan pembelajaran. Dengan gem5, sebuah komputer virtual (CPU, cache, bus, memori) dirakit lewat script Python, lalu sebuah program dijalankan di atasnya dan gem5 melaporkan statistik detail seperti jumlah cycle, jumlah instruksi, dan cache miss. Catatan ini mencakup pemasangan gem5 sampai menjalankan program "Hello World" pertama. == Persiapan == Catatan ini memakai Linux (Ubuntu/Debia..."

'''gem5''' adalah simulator arsitektur komputer open-source yang dipakai untuk riset dan pembelajaran. Dengan gem5, sebuah komputer virtual (CPU, cache, bus, memori) dirakit lewat script Python, lalu sebuah program dijalankan di atasnya dan gem5 melaporkan statistik detail seperti jumlah cycle, jumlah instruksi, dan cache miss.

Catatan ini mencakup pemasangan gem5 sampai menjalankan program "Hello World" pertama.

== Persiapan ==

Catatan ini memakai Linux (Ubuntu/Debian). Paket yang dibutuhkan (mengikuti dokumentasi gem5; cek [https://www.gem5.org/documentation/general_docs/building dokumentasi resmi] kalau versinya berbeda):

<syntaxhighlight lang="bash">
sudo apt install build-essential scons python3-dev git pre-commit \
zlib1g zlib1g-dev libprotobuf-dev protobuf-compiler libprotoc-dev \
libgoogle-perftools-dev libboost-all-dev libhdf5-serial-dev \
python3-pydot python3-venv python3-tk mypy m4 libcapstone-dev \
libpng-dev libelf-dev pkg-config wget cmake doxygen
</syntaxhighlight>

== Clone dan build ==

<syntaxhighlight lang="bash">
git clone https://github.com/gem5/gem5
cd gem5
scons build/ALL/gem5.opt -j <JUMLAH CPU>
</syntaxhighlight>

Keterangan:
* <code>build/ALL</code> artinya build mencakup semua ISA (x86, ARM, RISC-V, dan lainnya). Alternatifnya <code>build/X86/gem5.opt</code> kalau hanya butuh x86, build-nya lebih ringan.
* <code>gem5.opt</code> adalah varian dengan optimasi dan debug info secukupnya. Untuk debugging dengan gdb, pakai <code>gem5.debug</code> (lebih lambat, build lebih lama).
* <code>-j</code> menentukan jumlah proses paralel. Isi dengan hasil <code>nproc</code>. Build pertama memakan waktu lama dan banyak RAM; kalau RAM kurang, kecilkan nilai <code>-j</code>.

== Hello World pertama ==

gem5 menyertakan script contoh untuk menjalankan program sederhana:

<syntaxhighlight lang="bash">
build/ALL/gem5.opt configs/learning_gem5/part1/simple.py
</syntaxhighlight>

Script ini merakit satu CPU sederhana dengan memori, lalu menjalankan program "Hello World" di dalamnya (mode ''Syscall Emulation''). Kalau berhasil, di terminal muncul tulisan <code>Hello world!</code> dan baris penutup yang menyebut tick terakhir simulasi. Angka tick bisa berbeda antarversi gem5.

=== Isi folder <code>m5out/</code> ===

Setiap simulasi menghasilkan folder <code>m5out/</code> di direktori tempat gem5 dijalankan:

{| class="wikitable"
! File !! Isi
|-
| <code>stats.txt</code> || Semua statistik simulasi (cycle, instruksi, cache miss, dan lainnya)
|-
| <code>config.ini</code> / <code>config.json</code> || Konfigurasi sistem yang disimulasikan, lengkap dengan semua parameter
|-
| <code>config.dot.svg</code> || Diagram blok sistem
|}

Nilai yang pertama kali layak dilihat di <code>stats.txt</code>: <code>simSeconds</code>, <code>simInsts</code>, dan <code>system.cpu.numCycles</code>.

== Merakit sistem sendiri ==

Script berikut melakukan hal yang sama dengan <code>simple.py</code>, tetapi ditulis manual agar terlihat tiap komponennya.

<syntaxhighlight lang="python">
import m5
from m5.objects import *
from gem5.resources.resource import obtain_resource

system = System()
system.clk_domain = SrcClockDomain()
system.clk_domain.clock = "1GHz"
system.clk_domain.voltage_domain = VoltageDomain()

system.mem_mode = "timing"
system.mem_ranges = [AddrRange("512MB")]

system.cpu = X86TimingSimpleCPU()

system.membus = SystemXBar()

# Tanpa cache: CPU langsung ke membus
system.cpu.icache_port = system.membus.cpu_side_ports
system.cpu.dcache_port = system.membus.cpu_side_ports

# Khusus x86: interrupt controller disambung manual
system.cpu.createInterruptController()
system.cpu.interrupts[0].pio = system.membus.mem_side_ports
system.cpu.interrupts[0].int_requestor = system.membus.cpu_side_ports
system.cpu.interrupts[0].int_responder = system.membus.mem_side_ports

system.system_port = system.membus.cpu_side_ports

system.mem_ctrl = MemCtrl()
system.mem_ctrl.dram = DDR3_1600_8x8()
system.mem_ctrl.dram.range = system.mem_ranges[0]
system.mem_ctrl.port = system.membus.mem_side_ports

# Workload: program Hello World (SE mode)
binary = obtain_resource("x86-hello64-static").get_local_path()
system.workload = SEWorkload.init_compatible(binary)

process = Process()
process.cmd = [binary]
system.cpu.workload = process
system.cpu.createThreads()

root = Root(full_system=False, system=system)
m5.instantiate()

print("Beginning simulation!")
exit_event = m5.simulate()
print(f"Exiting @ tick {m5.curTick()} because {exit_event.getCause()}")
</syntaxhighlight>

Jalankan dengan:

<syntaxhighlight lang="bash">
build/ALL/gem5.opt my_simple.py
</syntaxhighlight>

Catatan: kalau resource <code>x86-hello64-static</code> tidak ditemukan di versi gem5 yang dipakai, ganti <code>binary</code> dengan path ke binary hello di source tree (<code>tests/test-progs/hello/bin/x86/linux/hello</code>).

=== Komponen yang dirakit ===

{| class="wikitable"
! Komponen !! Fungsi
|-
| <code>System</code> + <code>clk_domain</code> || Kerangka sistem dan clock (1 GHz)
|-
| <code>mem_mode = "timing"</code> || Akses memori dimodelkan dengan latency
|-
| <code>X86TimingSimpleCPU</code> || Satu core x86 sederhana yang menunggu respons memori
|-
| <code>SystemXBar</code> (<code>membus</code>) || Bus penghubung. <code>cpu_side_ports</code> untuk pihak yang meminta data (CPU), <code>mem_side_ports</code> untuk pihak yang menyediakan data (memori, device)
|-
| <code>interrupts[0]</code> || Interrupt controller x86, wajib disambung manual
|-
| <code>system_port</code> || Jalur khusus gem5 (misalnya untuk memuat binary ke memori sebelum simulasi)
|-
| <code>MemCtrl</code> + <code>DDR3_1600_8x8</code> || Memory controller dan DRAM
|}

== Tips: Makefile ==

Agar tidak mengetik path panjang berulang kali:

<syntaxhighlight lang="make">
GEM5 ?= /home/haidhi/gem5/build/ALL/gem5.opt
SCRIPT ?= simple.py
OUTDIR ?= m5out
FLAGS ?= Exec

.PHONY: run stats debug clean

run:
$(GEM5) --outdir=$(OUTDIR) $(SCRIPT)

stats:
@grep -E "simSeconds|simInsts|numCycles|hostSeconds" $(OUTDIR)/stats.txt

debug:
$(GEM5) --debug-flags=$(FLAGS) --debug-file=debug.out --outdir=$(OUTDIR) $(SCRIPT)

clean:
rm -rf $(OUTDIR)
</syntaxhighlight>

Baris perintah di Makefile harus diawali karakter '''tab''', bukan spasi.

== Masalah umum ==

* '''<code>No module named '_m5'</code>''': script gem5 tidak bisa dijalankan dengan <code>python3 script.py</code>. Modul <code>_m5</code> ditanam di dalam binary, jadi script harus dijalankan lewat <code>gem5.opt</code>.
* '''Garis bawah merah di VSCode untuk <code>System</code>, <code>SrcClockDomain</code>, dll''': modul <code>m5.objects</code> dibangkitkan saat build dan source-nya di-embed ke binary, sehingga IDE tidak menemukannya. Script tetap berjalan normal. Garis bawahnya bisa dimatikan lewat setting <code>python.analysis.diagnosticSeverityOverrides</code> atau komentar <code># pyright: reportUndefinedVariable=false</code> di baris atas script.
* '''Build gagal karena kehabisan memori''': kecilkan nilai <code>-j</code>.

Linux & Operating System

2026-10-11T08:42:36Z

SanzSkuy:

== Linux ==
* [[Cara install Arch Linux]]
* [[Linux from Scratch]]
* [[Install Arch Linux ARM di QEMU]]
* [[Bluetooth di Arch Linux (Pairing TWS)]]
* [[CUE 1.0]]

== Computer Systems ==
* [[Cara Kerja Floating Point]]
* [[Introduction to Assembly|Assembly Course]]
* [[Tahap-tahap dari source code menjadi executable file]]
* [[OS Manages Hardware]]
* [[Concurrency & Parallelism]]
* [[Unsigned Encodings]]

=== Representing and Manipulating Information ===
* [[CS:APP 2 Intro]]
* [[Accessing Information]]

=== temp ===
* [[Intro Compiler & Machine Abstraction]]

== gem5 ==
* [[gem5: hello world]]

== LLVM ==
* [[llvm: cara install]]

Accessing Information

2026-10-09T06:46:15Z

SanzSkuy:

CPU x86-64 punya '''16 general-purpose register''' berukuran 64-bit. Register ini menyimpan data integer dan pointer.

== Sejarah penamaan ==
Penamaan register berlapis karena evolusi instruction set:

{| class="wikitable"
! Generasi !! Lebar !! Nama register !! Catatan
|-
| 8086 || 16-bit || <code>%ax</code>, <code>%bx</code>, <code>%cx</code>, <code>%dx</code>, <code>%si</code>, <code>%di</code>, <code>%bp</code>, <code>%sp</code> || Nama mencerminkan fungsi (accumulator, counter, source/destination index, stack pointer)
|-
| IA32 || 32-bit || <code>%eax</code> … <code>%ebp</code> || Prefix <code>e</code> = ''extended''
|-
| x86-64 || 64-bit || <code>%rax</code> … <code>%rbp</code> || Prefix <code>r</code>
|-
| x86-64 (baru) || 64-bit || <code>%r8</code> … <code>%r15</code> || Konvensi baru, suffix <code>d</code>/<code>w</code>/<code>b</code> untuk 32/16/8-bit
|}

== Sub-register (nested boxes) ==
<code>%rax</code>, <code>%eax</code>, <code>%ax</code>, <code>%al</code> '''bukan''' empat register berbeda, melainkan satu register fisik yang diakses dengan lebar berbeda:

<pre>
|<------------------- %rax (64 bit) ------------------->|
|<------ %eax (32 bit) ----->|
|<- %ax (16) ->|
|%al(8)|
</pre>

* Operasi byte → least significant byte
* Operasi 16-bit → 2 byte terbawah
* Operasi 32-bit → 4 byte terbawah
* Operasi 64-bit → seluruh register

== Aturan sisa byte saat menulis ke register ==
Ketika instruksi menghasilkan nilai kurang dari 8 byte ke register:

{| class="wikitable"
! Ukuran tulis !! Efek ke byte sisanya
|-
| 1 byte / 2 byte || '''Tidak berubah'''
|-
| 4 byte || 4 byte atas '''di-nol-kan'''
|}

Contoh, dengan <code>%rax = 0x1122334455667788</code>:

<syntaxhighlight lang="gas">
movb $0xAA, %al # %rax = 0x11223344556677AA (sisanya utuh)
movw $0xAAAA, %ax # %rax = 0x112233445566AAAA (sisanya utuh)
movl $0xAAAA, %eax # %rax = 0x000000000000AAAA (4 byte atas = 0)
</syntaxhighlight>

'''Kenapa?''' Aturan zero-upper diadopsi saat ekspansi IA32 → x86-64 supaya hasil tulisan tidak bergantung pada isi lama register (menghindari ''partial register dependency''), sehingga eksekusi out-of-order lebih lancar. Compiler memanfaatkannya, misalnya <code>mov $0x0,%eax</code> untuk <code>return 0</code>.

== Peran register (System V ABI) ==
{| class="wikitable"
! Register !! Peran
|-
| <code>%rax</code> || Return value
|-
| <code>%rdi</code>, <code>%rsi</code>, <code>%rdx</code>, <code>%rcx</code>, <code>%r8</code>, <code>%r9</code> || Argumen ke-1 sampai ke-6 (urut)
|-
| <code>%rsp</code> || Stack pointer (spesial, dipakai otomatis oleh <code>push</code>/<code>pop</code>/<code>call</code>/<code>ret</code>)
|-
| <code>%rbx</code>, <code>%rbp</code>, <code>%r12</code>–<code>%r15</code> || '''Callee saved''': fungsi yang dipanggil wajib mengembalikan nilainya
|-
| <code>%r10</code>, <code>%r11</code> (+ register argumen & <code>%rax</code>) || '''Caller saved''': boleh dirusak oleh fungsi yang dipanggil
|}

Jembatan keledai urutan argumen: '''"Diane's Silk Dress Costs $89"''' → <code>di</code>, <code>si</code>, <code>dx</code>, <code>cx</code>, <code>8</code>, <code>9</code>.

=== Contoh: <code>multstore</code> ===
<syntaxhighlight lang="gas">
push %rbx # rbx callee-saved → simpan nilai lama
mov %rdx,%rbx # rdx = argumen ke-3 (dest), amankan di rbx
call mult2 # x, y masih di rdi & rsi
mov %rax,(%rbx) # *dest = hasil mult2 (rax)
pop %rbx # pulihkan rbx
ret
</syntaxhighlight>
<code>dest</code> dipindah ke <code>%rbx</code> karena <code>%rdx</code> caller-saved (bisa dirusak <code>mult2</code>), sedangkan <code>%rbx</code> dijamin selamat melewati <code>call</code>.

= 3.4.1 Operand Specifiers =

== Tiga jenis operand ==
{| class="wikitable"
! Jenis !! Contoh !! Arti
|-
| Immediate || <code>$-577</code>, <code>$0x1F</code> || Konstanta, nilai tertanam di instruksi
|-
| Register || <code>%rax</code>, <code>%al</code> || Isi register, notasi <code>R[ra]</code>
|-
| Memory || <code>0x104</code>, <code>(%rax)</code>, <code>8(%rax)</code> || Isi memori di ''effective address'', notasi <code>M[Addr]</code>
|}

'''Perhatian:''' <code>$0x10</code> = angka 16, sedangkan <code>0x10</code> (tanpa <code>$</code>) = isi memori di alamat 16.

== <code>%rax</code> vs <code>(%rax)</code> ==
* <code>%rax</code> → isi register itu sendiri (seperti <code>p</code> di C)
* <code>(%rax)</code> → isi register dipakai sebagai alamat, lalu baca memori di alamat itu (seperti <code>*p</code> di C)

Kurung <code>( )</code> di AT&T = dereference. Di AT&T, register '''wajib''' pakai <code>%</code>; <code>rax</code> tanpa <code>%</code> akan dianggap nama simbol.

{| class="wikitable"
! Maksud !! AT&T (gcc, CS:APP) !! Intel (NASM, MASM)
|-
| Isi register || <code>%rax</code> || <code>rax</code>
|-
| Isi memori di alamat rax || <code>(%rax)</code> || <code>[rax]</code>
|-
| Konstanta || <code>$5</code> || <code>5</code>
|}

== Bentuk umum memory reference ==
<pre>
Imm(rb, ri, s) → alamat = Imm + R[rb] + R[ri] · s
</pre>
* <code>Imm</code>: displacement konstanta
* <code>rb</code>: base register (64-bit)
* <code>ri</code>: index register (64-bit)
* <code>s</code>: skala, hanya '''1, 2, 4, atau 8''' (ukuran <code>char</code>, <code>short</code>, <code>int</code>, <code>long</code>/pointer)

Semua mode lain adalah kasus khusus dengan komponen yang dihilangkan:

{| class="wikitable"
! Form !! Effective address !! Nama
|-
| <code>Imm</code> || <code>Imm</code> || Absolute
|-
| <code>(rb)</code> || <code>R[rb]</code> || Indirect
|-
| <code>Imm(rb)</code> || <code>Imm + R[rb]</code> || Base + displacement
|-
| <code>(rb,ri)</code> || <code>R[rb] + R[ri]</code> || Indexed
|-
| <code>Imm(rb,ri)</code> || <code>Imm + R[rb] + R[ri]</code> || Indexed
|-
| <code>(,ri,s)</code> || <code>R[ri]·s</code> || Scaled indexed
|-
| <code>Imm(,ri,s)</code> || <code>Imm + R[ri]·s</code> || Scaled indexed
|-
| <code>(rb,ri,s)</code> || <code>R[rb] + R[ri]·s</code> || Scaled indexed
|-
| <code>Imm(rb,ri,s)</code> || <code>Imm + R[rb] + R[ri]·s</code> || Scaled indexed
|}

Tambahan x86-64 yang tidak ada di tabel: '''RIP-relative''', misalnya <code>lea 0x0(%rip),%rdi</code>, alamat dihitung relatif terhadap instruksi berikutnya (dipakai untuk data global/string literal).

== Kegunaan: akses array dan struct ==
<syntaxhighlight lang="c">
long a[100];
x = a[i];
</syntaxhighlight>
Dengan <code>a</code> di <code>%rdx</code> dan <code>i</code> di <code>%rcx</code>:
<syntaxhighlight lang="gas">
movq (%rdx,%rcx,8), %rax # alamat = a + i*8
</syntaxhighlight>
Satu instruksi tanpa perkalian terpisah. Untuk <code>arr[i].field</code>, offset field masuk ke <code>Imm</code>.

== Cara menghitung nilai operand ==
Untuk memory operand selalu dua langkah:
# Hitung alamat: <code>Imm + R[rb] + R[ri]·s</code>
# Baca isi memori di alamat tersebut

'''Jebakan umum:'''
* Displacement tanpa <code>0x</code> adalah '''desimal''': <code>260</code> = <code>0x104</code>, <code>16</code> = <code>0x10</code>
* Koma di depan (<code>0xFC(,%rcx,4)</code>) berarti '''tanpa base register'''
* Perhatikan carry saat menjumlah hex: <code>0xFC + 4 = 0x100</code>
* Jangan berhenti di alamat; jawaban adalah '''isi''' memorinya

=== Contoh (Practice Problem 3.1) ===
Data: <code>%rax = 0x100</code>, <code>%rcx = 0x1</code>, <code>%rdx = 0x3</code>; memori <code>0x100→0xFF</code>, <code>0x104→0xAB</code>, <code>0x108→0x13</code>, <code>0x10C→0x11</code>.

{| class="wikitable"
! Operand !! Jenis !! Alamat !! Nilai
|-
| <code>%rax</code> || Register || — || <code>0x100</code>
|-
| <code>0x104</code> || Absolute || <code>0x104</code> || <code>0xAB</code>
|-
| <code>$0x108</code> || Immediate || — || <code>0x108</code>
|-
| <code>(%rax)</code> || Indirect || <code>0x100</code> || <code>0xFF</code>
|-
| <code>4(%rax)</code> || Base + displacement || <code>4 + 0x100 = 0x104</code> || <code>0xAB</code>
|-
| <code>9(%rax,%rdx)</code> || Indexed || <code>9 + 0x100 + 3 = 0x10C</code> || <code>0x11</code>
|-
| <code>260(%rcx,%rdx)</code> || Indexed || <code>0x104 + 1 + 3 = 0x108</code> || <code>0x13</code>
|-
| <code>0xFC(,%rcx,4)</code> || Scaled indexed || <code>0xFC + 1·4 = 0x100</code> || <code>0xFF</code>
|-
| <code>(%rax,%rdx,4)</code> || Scaled indexed || <code>0x100 + 3·4 = 0x10C</code> || <code>0x11</code>
|}

Accessing Information

2026-10-09T06:45:45Z

SanzSkuy: Created page with "CPU x86-64 punya '''16 general-purpose register''' berukuran 64-bit. Register ini menyimpan data integer dan pointer. == Sejarah penamaan == Penamaan register berlapis karena evolusi instruction set: {| class="wikitable" ! Generasi !! Lebar !! Nama register !! Catatan |- | 8086 || 16-bit || <code>%ax</code>, <code>%bx</code>, <code>%cx</code>, <code>%dx</code>, <code>%si</code>, <code>%di</code>, <code>%bp</code>, <code>%sp</code> || Nama mencerminkan fungsi (accumulat..."

Linux & Operating System

2026-10-09T06:45:18Z

SanzSkuy:

Main Page

2026-10-09T01:50:09Z

SanzSkuy:

'''Haidhi Angkawijana Tedja''' 
Software Engineer @ Telkom Indonesia

I write everything that I learn

[https://github.com/haidhiSkuy GitHub] • [https://www.linkedin.com/in/haidhi-angkawijana-tedja/ LinkedIn] • haidhiangkawijana@gmail.com

== Research Interests ==
* Heterogeneous Computing
* High-Performance Computing (HPC)
* GPU/Accelerator Architectures
* Edge Computing
* Hardware-Software Co-design for AI Systems

== Education ==
=== South Tangerang Institute of Technology (ITTS) ===
''2021 – 2025''
* B.Sc. in Computer Science
* Undergraduate Thesis: "Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization"
* Advised by [https://id.wikipedia.org/wiki/Onno_W._Purbo Onno W. Purbo]

=== Riyadhussholihiin Islamic Boarding School ===
''2016 - 2021''
* Language Class (Arabic)
* Organisasi Santri Riyadhussholihin (OSRIY) & Baitul Qur'an
* Grade: Mumtaz (excellent)

== Work Experience ==
* Telkom Indonesia — AI & Backend Engineer ''(July 2024 – Present)''
* Meister Sinergi Indonesia (AERY) — ML/AI Engineer ''(October 2023 – Present)''
* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''
* Riyadhussholihiin Islamic Boarding School, Pandeglang — Teacher ''(July 2020 - July 2021)''

== Publication ==
* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608

== CV ==
* [https://drive.google.com/file/d/1y4H7s0E_N3XzCqi9o1iVPRj-KdLHOlEJ/view?usp=sharing CV_Haidhi_Angkawijana_Tedja.pdf]

== Categories ==
* [[Daftar Isi AI/ML|Artificial Intelligence, Machine Learning, & Data Science]]
* [[Daftar Isi Cybersecurity|Cybersecurity]]
* [[Linux & Operating System]]
* [[DevOps]]
* [[Web Assembly]]
* [[High-performance computing]]
* [[Programming, Software Engineering, etc]]
* [[Aerospace Engineering]]
* [[Istilah Penting]]

 
<pre>
Imam Syafi'i رحمه الله:

الْعِلْمُ صَيْدٌ وَالْكِتَابَةُ قَيْدُهُ * قَيِّدْ صُيُوْدَكَ بِالْحِبَالِ الْوَاثِقَهْ
فَمِنَ الْحَمَاقَةِ أَنْ تَصِيْدَ غَزَالَةً وَتَتْرُكَهَا بَيْنَ الْخَلاَئِقِ طَالِقَهْ

Knowledge is a quarry, and the written word its chain.
Bind thy quarry fast with cords unyielding.
For folly it is to hunt the stag,
Only to loose it once more among the wilds.
</pre>

Intro Compiler & Machine Abstraction

2026-10-06T07:07:14Z

SanzSkuy: Created page with "{{Catatan|Catatan ini merangkum dua topik yang saling berkaitan: '''optimisasi compiler''' dan '''abstraksi level mesin''' (ISA, virtual address, processor state x86-64). Materi mengikuti alur pembukaan Bab 3 CS:APP.}} == Compiler Optimization == '''Optimisasi''' adalah proses compiler mengubah kode sumber menjadi bentuk yang lebih cepat, lebih kecil, atau lebih hemat sumber daya, '''tanpa mengubah perilaku program yang teramati dari luar'''. Programmer menulis kode y..."

{{Catatan|Catatan ini merangkum dua topik yang saling berkaitan: '''optimisasi compiler''' dan '''abstraksi level mesin''' (ISA, virtual address, processor state x86-64). Materi mengikuti alur pembukaan Bab 3 CS:APP.}}

== Compiler Optimization ==

'''Optimisasi''' adalah proses compiler mengubah kode sumber menjadi bentuk yang lebih cepat, lebih kecil, atau lebih hemat sumber daya, '''tanpa mengubah perilaku program yang teramati dari luar'''.

Programmer menulis kode yang mudah dibaca manusia; compiler menerjemahkannya menjadi kode mesin yang efisien.

=== Aturan dasar: ''as-if rule'' ===

Compiler boleh melakukan transformasi apa pun selama program berperilaku '''seolah-olah''' tidak diubah. Output akhir harus tetap sama.

{{Warning|''Undefined behavior'' (UB) di C/C++ dapat menghasilkan perilaku yang tampak aneh justru karena aturan ini. Compiler berasumsi UB '''tidak pernah terjadi''', lalu melakukan optimisasi berdasarkan asumsi tersebut. Kode yang "kelihatannya benar" bisa dihapus atau diubah total.}}

=== Jenis-jenis optimisasi ===

; Constant folding
: Ekspresi konstan dihitung saat kompilasi. <code>x = 2 * 3 + 4</code> menjadi <code>x = 10</code>.
; Dead code elimination
: Kode yang tidak pernah dieksekusi, atau yang hasilnya tidak pernah dipakai, dibuang.
; Inlining
: Pemanggilan fungsi kecil diganti langsung dengan isi fungsinya, menghilangkan overhead ''call''.
; Loop unrolling
: Badan loop "dibentangkan" untuk mengurangi overhead pengecekan kondisi dan lompatan.
; Common subexpression elimination
: Ekspresi yang dihitung berulang cukup dihitung satu kali.
; Vectorization (SIMD)
: Beberapa operasi data diproses sekaligus dalam satu instruksi, memanfaatkan ''vector register''.
; Register allocation
: Variabel yang sering dipakai ditempatkan di register CPU, bukan di memori.

{{Tip|Register x86-64 hanya ada '''16 buah'''. Keterbatasan inilah yang membuat ''register allocation'' menjadi salah satu masalah tersulit dalam desain compiler. Variabel yang tidak kebagian register harus di-''spill'' ke stack, dan itu jauh lebih lambat.}}

=== Flag optimisasi ===

{| class="wikitable"
! Flag !! Keterangan
|-
| <code>-O0</code> || Tanpa optimisasi. Paling nyaman untuk ''debugging'' karena kode mesin masih memetakan rapi ke kode sumber.
|-
| <code>-O1</code> || Optimisasi dasar.
|-
| <code>-O2</code> || Standar untuk produksi.
|-
| <code>-O3</code> || Lebih agresif, termasuk vectorization dan inlining yang lebih luas.
|-
| <code>-Os</code> || Mengutamakan ukuran biner yang kecil.
|}

Di Rust, mode optimisasi diaktifkan dengan <code>cargo build --release</code>.

{{Tip|Saat ''debugging'', gunakan <code>-O0</code>. Pada level optimisasi tinggi, variabel bisa hilang dari ''debugger'', urutan eksekusi berubah, dan ''breakpoint'' tidak mendarat di tempat yang diharapkan.}}

== Abstraksi dalam Sistem Komputer ==

'''Abstraksi''' adalah menyembunyikan detail implementasi di balik model yang lebih sederhana. Untuk pemrograman level mesin, ada dua abstraksi yang paling penting.

=== 1. Instruction Set Architecture (ISA) ===

ISA adalah "kontrak" antara perangkat keras dan perangkat lunak. ISA mendefinisikan:

* '''Processor state''' — apa saja yang disimpan prosesor (register, program counter, condition flag)
* '''Format instruksi''' — bagaimana instruksi dikodekan
* '''Efek tiap instruksi''' terhadap state tersebut

Sebagian besar ISA, termasuk '''x86-64''', mendeskripsikan perilaku program '''seolah-olah''' setiap instruksi dieksekusi berurutan: satu instruksi selesai sebelum instruksi berikutnya dimulai.

==== Kenyataan di perangkat keras ====

Prosesor nyata jauh lebih rumit dan mengeksekusi banyak instruksi secara '''konkuren''':

* '''Pipelining''' — beberapa tahap instruksi tumpang tindih
* '''Superscalar''' — beberapa instruksi dieksekusi bersamaan
* '''Out-of-order execution''' — urutan eksekusi disusun ulang sesuai kesiapan data
* '''Speculative execution''' — prosesor menebak hasil percabangan sebelum diketahui

Prosesor menggunakan '''pengaman''' (''dependency checking'', ''reorder buffer'', ''in-order commit'') untuk memastikan hasil akhirnya tetap identik dengan model sekuensial yang dijanjikan ISA.

{{Catatan|Pola yang sama muncul di dua lapisan berbeda. Compiler boleh mengubah urutan kode (''as-if rule''), hardware boleh mengubah urutan eksekusi — keduanya sah '''selama perilaku yang teramati tidak berubah'''.}}

=== 2. Virtual Address ===

Alamat memori yang dipakai program level mesin adalah '''alamat virtual''', yang menyajikan memori sebagai '''satu array byte yang sangat besar dan berurutan'''.

Implementasi sebenarnya jauh lebih kompleks:

* Hierarki perangkat keras: register → cache L1/L2/L3 → DRAM → disk
* Perangkat lunak sistem operasi: ''page table'', MMU, TLB, penanganan ''page fault'', ''swapping''

Sistem operasi mengelola ruang alamat virtual dan menerjemahkan alamat virtual menjadi alamat fisik.

==== Ukuran ruang alamat x86-64 ====

* Alamat direpresentasikan sebagai word '''64-bit'''
* Pada implementasi saat ini, '''16 bit teratas harus bernilai nol'''
* Ruang alamat efektif = 248 byte ≈ '''64 terabyte'''
* Program biasa hanya memakai beberapa megabyte sampai beberapa gigabyte

{{Warning|Pada satu waktu, hanya sebagian kecil rentang alamat virtual yang dianggap '''valid'''. Akses ke alamat yang tidak valid inilah yang memunculkan ''segmentation fault''.}}

=== Abstraksi yang bocor (''leaky abstraction'') ===

Kedua abstraksi di atas membuat assembly bisa dipelajari sama sekali. Namun abstraksi tersebut '''bocor''' dalam beberapa situasi:

* '''Performa''' — ISA menjanjikan urutan, tetapi ''cache miss'' dan ''branch misprediction'' tetap memengaruhi kecepatan nyata
* '''Konkurensi''' — model sekuensial tidak lagi cukup ketika beberapa thread berinteraksi, sehingga diperlukan ''memory barrier'' dan operasi atomik
* '''Keamanan''' — Spectre dan Meltdown adalah kasus di mana pengaman ternyata tidak sempurna: ''speculative execution'' meninggalkan jejak di cache yang bisa dibaca penyerang

== Representasi Level Mesin ==

Compiler mengerjakan bagian terberat: menerjemahkan model eksekusi C yang relatif abstrak menjadi instruksi prosesor yang sangat elementer.

'''Assembly''' dan '''machine code''' pada dasarnya sama; perbedaannya hanya representasi. Assembly berbentuk teks yang bisa dibaca manusia, machine code berbentuk biner. Hubungan keduanya nyaris satu-ke-satu.

=== Processor state yang terlihat ===

Bagian-bagian state prosesor berikut tersembunyi dari programmer C, tetapi terlihat jelas di level mesin.

==== Program counter (<code>%rip</code>) ====

Menyimpan '''alamat memori instruksi berikutnya''' yang akan dieksekusi. Di C, posisi eksekusi adalah konsep implisit; di level mesin, ini register konkret yang dapat diubah lewat instruksi lompat dan pemanggilan fungsi.

==== Integer register file ====

16 lokasi bernama, masing-masing menyimpan nilai '''64-bit'''. Isinya dapat berupa alamat (setara pointer di C) atau data integer.

{| class="wikitable"
! Register !! Peran umum (System V AMD64 ABI)
|-
| <code>%rax</code> || Nilai kembalian fungsi
|-
| <code>%rbx</code> || ''Callee-saved''
|-
| <code>%rcx</code> || Argumen ke-4
|-
| <code>%rdx</code> || Argumen ke-3
|-
| <code>%rsi</code> || Argumen ke-2
|-
| <code>%rdi</code> || Argumen ke-1
|-
| <code>%rbp</code> || ''Callee-saved'' / ''frame pointer''
|-
| <code>%rsp</code> || ''Stack pointer''
|-
| <code>%r8</code> || Argumen ke-5
|-
| <code>%r9</code> || Argumen ke-6
|-
| <code>%r10</code>, <code>%r11</code> || ''Caller-saved'', data sementara
|-
| <code>%r12</code>–<code>%r15</code> || ''Callee-saved''
|}

Sebagian register melacak bagian penting dari state program, sebagian lain menampung data sementara seperti argumen, variabel lokal, dan nilai kembalian.

==== Condition code register ====

Menyimpan informasi status hasil operasi aritmetika atau logika '''yang terakhir dieksekusi''' (''zero flag'', ''sign flag'', ''carry'', ''overflow'').

Register inilah yang dipakai untuk mengimplementasikan perubahan alur kontrol bersyarat seperti <code>if</code> dan <code>while</code>:

# Instruksi pembanding dieksekusi → flag berubah
# Instruksi lompat bersyarat membaca flag → alur program bercabang

{{Catatan|Satu pernyataan <code>if</code> di C selalu "dicicil" menjadi minimal dua langkah terpisah di level mesin: penetapan flag, lalu pembacaan flag.}}

==== Vector register ====

Setiap register dapat menampung '''satu atau lebih''' nilai integer atau floating-point sekaligus. Inilah dasar perangkat keras untuk SIMD dan ''vectorization''.

=== Memori: tipe data adalah ilusi ===

C menyediakan model di mana objek dengan tipe berbeda dideklarasikan dan dialokasikan di memori. Kode mesin memandang memori '''semata-mata sebagai array byte besar yang dapat dialamati'''.

Konsekuensinya:

* Tipe agregat seperti ''array'' dan ''struct'' direpresentasikan sebagai '''kumpulan byte yang bersebelahan'''
* Assembly '''tidak membedakan''' integer ''signed'' dan ''unsigned''
* Assembly tidak membedakan jenis pointer satu sama lain
* Assembly bahkan '''tidak membedakan pointer dari integer'''

{{Warning|Yang membedakan ''signed'' dan ''unsigned'' bukan datanya, melainkan '''instruksi mana yang dipilih''' untuk mengolahnya. Pola bit-nya identik. Inilah sebabnya kesalahan tipe data di C bisa lolos tanpa gejala sampai jauh di kemudian hari.}}

{{Tip|Hal ini juga menjelaskan mengapa ''casting'' pointer di C praktis "gratis" di level mesin — tidak ada data yang berubah, hanya cara compiler memperlakukannya.}}

=== Isi program memory ===

Ruang memori program berisi:

* Kode mesin yang dapat dieksekusi
* Informasi yang dibutuhkan sistem operasi
* '''Run-time stack''' untuk mengelola pemanggilan dan pengembalian prosedur
* Blok memori yang dialokasikan pengguna, misalnya melalui <code>malloc</code>

Seluruhnya dialamati menggunakan alamat virtual.

=== Satu instruksi = satu operasi elementer ===

Satu instruksi mesin hanya melakukan operasi yang sangat sederhana, misalnya:

* Menjumlahkan dua angka yang tersimpan di register
* Memindahkan data antara memori dan register
* Melompat ke alamat instruksi lain secara bersyarat

Compiler harus '''menyusun rangkaian''' instruksi semacam itu untuk mengimplementasikan konstruksi program seperti evaluasi ekspresi aritmetika, loop, serta pemanggilan dan pengembalian prosedur.

{{Catatan|Inilah gambaran besarnya. C menyediakan objek bertipe, variabel bernama, dan struktur kontrol. Mesin hanya punya 16 register, array byte, flag, dan instruksi sederhana. '''Jarak antara keduanya diisi oleh compiler''' — dan membaca hasil pengisian jarak itulah inti dari Bab 3 CS:APP.}}

Linux & Operating System

2026-10-06T07:07:07Z

SanzSkuy:

== Linux ==
* [[Cara install Arch Linux]]
* [[Linux from Scratch]]
* [[Install Arch Linux ARM di QEMU]]
* [[Bluetooth di Arch Linux (Pairing TWS)]]
* [[CUE 1.0]]

== Computer Systems ==
* [[Cara Kerja Floating Point]]
* [[Introduction to Assembly|Assembly Course]]
* [[Tahap-tahap dari source code menjadi executable file]]
* [[OS Manages Hardware]]
* [[Concurrency & Parallelism]]
* [[Unsigned Encodings]]

=== Representing and Manipulating Information ===
* [[CS:APP 2 Intro]]

=== temp ===
* [[Intro Compiler & Machine Abstraction]]

== LLVM ==
* [[llvm: cara install]]

Main Page

2026-09-18T03:09:56Z

SanzSkuy:

'''Haidhi Angkawijana Tedja''' 
Software Engineer @ Telkom Indonesia

I write everything that I learn

[https://github.com/haidhiSkuy GitHub] • [https://www.linkedin.com/in/haidhi-angkawijana-tedja/ LinkedIn] • haidhiangkawijana@gmail.com

== Research Interests ==
* Heterogeneous Computing
* High-Performance Computing (HPC)
* GPU/Accelerator Architectures
* Edge Computing
* Hardware-Software Co-design for AI Systems

== Education ==
=== South Tangerang Institute of Technology (ITTS) ===
''2021 – 2025''
* B.Sc. in Computer Science
* Undergraduate Thesis: "Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization"
* Advised by [https://id.wikipedia.org/wiki/Onno_W._Purbo Onno W. Purbo]

=== Riyadhussholihiin Islamic Boarding School ===
''2016 - 2021''
* Language Class (Arabic)
* Organisasi Santri Riyadhussholihin (OSRIY) & Baitul Qur'an
* Grade: Mumtaz (excellent)

== Work Experience ==
* Telkom Indonesia — AI & Backend Engineer ''(July 2024 – Present)''
* Meister Sinergi Indonesia (AERY) — ML/AI Engineer ''(October 2023 – Present)''
* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''
* Riyadhussholihiin Islamic Boarding School, Pandeglang — Tahfidz Teacher ''(July 2020 - July 2021)''

== Publication ==
* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608

== CV ==
* [https://drive.google.com/file/d/1y4H7s0E_N3XzCqi9o1iVPRj-KdLHOlEJ/view?usp=sharing CV_Haidhi_Angkawijana_Tedja.pdf]

== Categories ==
* [[Daftar Isi AI/ML|Artificial Intelligence, Machine Learning, & Data Science]]
* [[Daftar Isi Cybersecurity|Cybersecurity]]
* [[Linux & Operating System]]
* [[DevOps]]
* [[Web Assembly]]
* [[High-performance computing]]
* [[Programming, Software Engineering, etc]]
* [[Aerospace Engineering]]
* [[Istilah Penting]]

 
<pre>
Imam Syafi'i رحمه الله:

الْعِلْمُ صَيْدٌ وَالْكِتَابَةُ قَيْدُهُ * قَيِّدْ صُيُوْدَكَ بِالْحِبَالِ الْوَاثِقَهْ
فَمِنَ الْحَمَاقَةِ أَنْ تَصِيْدَ غَزَالَةً وَتَتْرُكَهَا بَيْنَ الْخَلاَئِقِ طَالِقَهْ

Knowledge is a quarry, and the written word its chain.
Bind thy quarry fast with cords unyielding.
For folly it is to hunt the stag,
Only to loose it once more among the wilds.
</pre>

Main Page

2026-09-09T01:37:26Z

SanzSkuy:

'''Haidhi Angkawijana Tedja''' 
Software Engineer @ Telkom Indonesia

I write everything that I learn

[https://github.com/haidhiSkuy GitHub] • [https://www.linkedin.com/in/haidhi-angkawijana-tedja/ LinkedIn] • haidhiangkawijana@gmail.com

== Research Interests ==
* Heterogeneous Computing
* High-Performance Computing (HPC)
* GPU/Accelerator Architectures
* Edge Computing
* Hardware-Software Co-design for AI Systems

== Education ==
=== South Tangerang Institute of Technology (ITTS) ===
''2021 – 2025''
* B.Sc. in Computer Science
* Undergraduate Thesis: "Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization"
* Advised by [https://id.wikipedia.org/wiki/Onno_W._Purbo Onno W. Purbo]

=== Riyadhussholihiin Islamic Boarding School ===
''2016 - 2021''
* Language Class (Arabic)
* Organisasi Santri Riyadhussholihin (OSRIY) & Baitul Qur'an
* Grade: Mumtaz (excellent)

== Work Experience ==
* Telkom Indonesia — AI & Backend Engineer ''(July 2024 – Present)''
* Meister Sinergi Indonesia (AERY) — ML/AI Engineer ''(October 2023 – Present)''
* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''
* Riyadhussholihiin Islamic Boarding School, Pandeglang — Tahfidz Teacher ''(July 2020 - July 2021)''

== Publication ==
* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608

== CV ==
* [https://drive.google.com/file/d/1y4H7s0E_N3XzCqi9o1iVPRj-KdLHOlEJ/view?usp=sharing CV_Haidhi_Angkawijana_Tedja.pdf]

== Categories ==
* [[Daftar Isi AI/ML|Artificial Intelligence, Machine Learning, & Data Science]]
* [[Daftar Isi Cybersecurity|Cybersecurity]]
* [[Linux & Operating System]]
* [[DevOps]]
* [[Web Assembly]]
* [[High-performance computing]]
* [[Programming, Software Engineering, etc]]
* [[Aerospace Engineering]]
* [[Ringkasan Buku]]
* [[Istilah Penting]]

 
<pre>
Imam Syafi'i رحمه الله:

الْعِلْمُ صَيْدٌ وَالْكِتَابَةُ قَيْدُهُ * قَيِّدْ صُيُوْدَكَ بِالْحِبَالِ الْوَاثِقَهْ
فَمِنَ الْحَمَاقَةِ أَنْ تَصِيْدَ غَزَالَةً وَتَتْرُكَهَا بَيْنَ الْخَلاَئِقِ طَالِقَهْ

Knowledge is a quarry, and the written word its chain.
Bind thy quarry fast with cords unyielding.
For folly it is to hunt the stag,
Only to loose it once more among the wilds.
</pre>

Unsigned Encodings

2026-09-08T02:57:00Z

SanzSkuy: Created page with "Section ini menjawab satu pertanyaan: '''kalau kita punya deretan angka 0 dan 1, bagaimana cara membacanya sebagai satu bilangan biasa?''' Plus satu jaminan tambahan: '''pembacaan itu unik dan bisa dibalik'''. Itu saja isinya. Sisanya cuma cara menuliskannya secara rapi. = Bagian 1: Membangun idenya dari nol = == Langkah 0: Ingat dulu cara kerja angka desimal == Sebelum masuk biner, kita ulang dulu sesuatu yang sudah kita pakai sejak kecil tanpa sadar. Ambil angka..."

Section ini menjawab satu pertanyaan: '''kalau kita punya deretan angka 0 dan 1, bagaimana cara membacanya sebagai satu bilangan biasa?'''

Plus satu jaminan tambahan: '''pembacaan itu unik dan bisa dibalik'''.

Itu saja isinya. Sisanya cuma cara menuliskannya secara rapi.

= Bagian 1: Membangun idenya dari nol =

== Langkah 0: Ingat dulu cara kerja angka desimal ==

Sebelum masuk biner, kita ulang dulu sesuatu yang sudah kita pakai sejak kecil tanpa sadar.

Ambil angka '''507'''. Kenapa dia bernilai lima ratus tujuh?

Karena tiap posisi digit punya '''nilai tempat''' sendiri:

<pre>
5 0 7
| | |
100 10 1 <- nilai tempat tiap posisi
</pre>

Lalu kita kalikan dan jumlahkan:

<pre>
5 x 100 = 500
0 x 10 = 0
7 x 1 = 7
-----
507
</pre>

Perhatikan pola nilai tempatnya: 1, 10, 100, 1000 — '''naik sepuluh kali lipat''' tiap geser satu posisi ke kiri. Karena itu namanya sistem '''basis 10'''.

{{Catatan|Inti yang perlu dibawa ke langkah berikutnya: angka itu bukan sekadar deretan simbol. Tiap posisi punya bobot, dan nilai totalnya adalah jumlah dari digit dikali bobotnya.}}

== Langkah 1: Biner memakai ide yang sama persis ==

Biner bekerja dengan cara yang sama. Yang berubah cuma dua hal:

# Digitnya cuma boleh '''0 atau 1''' (bukan 0 sampai 9)
# Nilai tempatnya '''naik dua kali lipat''', bukan sepuluh kali lipat

Jadi nilai tempatnya jadi seperti ini:

<pre>
... 8 4 2 1
</pre>

Atau kalau ditulis sebagai pangkat dua:

<pre>
... 2^3 2^2 2^1 2^0
... 8 4 2 1
</pre>

{{Tip|Kalau lupa, tinggal mulai dari 1 di paling kanan lalu kalikan dua terus ke kiri: 1, 2, 4, 8, 16, 32, 64, 128, ...}}

== Langkah 2: Cara menomori posisi bit ==

Ini bagian yang bikin orang tersesat kalau kelewat, jadi pelan-pelan.

Buku menomori bit '''dari kanan, dimulai dari nol'''.

<pre>
posisi: 3 2 1 0
| | | |
bit: [ 1 0 1 1 ]
| |
| +--- ini x_0, bit paling kanan
+--------------------- ini x_3, bit paling kiri
</pre>

Jadi untuk vektor bit selebar '''w''' bit, penulisannya:

<pre>
[ x_(w-1), x_(w-2), ... , x_1, x_0 ]
</pre>

Buku juga memakai lambang <code>x</code> bertanda panah di atasnya untuk menyebut '''seluruh vektor sekaligus''', sementara <code>x_i</code> menyebut '''satu bit tertentu'''.

{{Warning|title=Jangan sampai kebalik|Nomor posisi dihitung '''dari kanan''' dan '''dimulai dari 0''', bukan dari kiri dan bukan dimulai dari 1. Kalau ini kebalik, semua rumus di sisa bab akan menghasilkan angka yang salah. Alasan penomorannya begitu: supaya nomor posisi langsung sama dengan pangkat duanya — posisi 3 bernilai 2 pangkat 3.}}

== Langkah 3: Aturannya cuma satu kalimat ==

Sekarang aturan intinya:

; '''Kalau sebuah bit bernilai 1, dia menyumbang nilai tempatnya. Kalau bernilai 0, dia tidak menyumbang apa-apa.'''

Bayangkan tiap posisi bit sebagai '''saklar lampu''' yang punya harga tetap:

<pre>
saklar 8 saklar 4 saklar 2 saklar 1
[ ] [ ] [ ] [ ]
</pre>

Menyalakan saklar berarti membayar harganya. Nilai akhirnya adalah '''total harga saklar yang menyala'''.

= Bagian 2: Rumus resminya =

== Langkah 4: Membongkar rumus 2.1 ==

Buku menuliskan aturan tadi seperti ini:

<pre>
w-1
B2U (x) = SUM x . 2^i
w i=0 i
</pre>

Kelihatan menakutkan, padahal isinya persis kalimat di Langkah 3. Kita bongkar potongan demi potongan:

{| class="wikitable"
! Potongan !! Artinya dalam bahasa sehari-hari
|-
| <code>B2U</code> || Singkatan dari ''binary to unsigned'' — "dari biner ke tak bertanda"
|-
| <code>w</code> di bawah || Lebarnya berapa bit
|-
| <code>SUM</code> (lambang sigma) || "Jumlahkan semuanya"
|-
| <code>i=0</code> sampai <code>w-1</code> || "Untuk tiap posisi, mulai dari posisi 0 sampai posisi terakhir"
|-
| <code>x_i</code> || Nilai bit di posisi itu, 0 atau 1
|-
| <code>2^i</code> || Nilai tempat posisi itu
|-
| <code>x_i . 2^i</code> || Bit dikali nilai tempatnya — inilah "sumbangan" posisi itu
|}

Dibaca utuh: '''untuk tiap posisi bit, kalikan nilai bitnya dengan nilai tempatnya, lalu jumlahkan semuanya.'''

{{Catatan|title=Soal lambang titik-sama-dengan|Buku memakai lambang <code>=</code> dengan titik di atasnya. Artinya "ruas kiri '''didefinisikan''' sama dengan ruas kanan". Jadi ini bukan hasil hitungan yang diturunkan dari mana-mana, melainkan kesepakatan tentang apa arti B2U. Mirip seperti mengatakan "yang kami maksud dengan ini adalah itu".}}

== Langkah 5: Empat contoh, dikerjakan pelan-pelan ==

Semua contoh di bawah memakai '''w = 4''', jadi nilai tempatnya: 8, 4, 2, 1.

=== Contoh 1: [0001] ===

<pre>
posisi: 3 2 1 0
bit: 0 0 0 1
nilai tempat: 8 4 2 1
sumbangan: 0 0 0 1
</pre>

Hitung: 0 + 0 + 0 + 1 = '''1'''

=== Contoh 2: [0101] ===

<pre>
posisi: 3 2 1 0
bit: 0 1 0 1
nilai tempat: 8 4 2 1
sumbangan: 0 4 0 1
</pre>

Hitung: 0 + 4 + 0 + 1 = '''5'''

=== Contoh 3: [1011] ===

<pre>
posisi: 3 2 1 0
bit: 1 0 1 1
nilai tempat: 8 4 2 1
sumbangan: 8 0 2 1
</pre>

Hitung: 8 + 0 + 2 + 1 = '''11'''

=== Contoh 4: [1111] ===

<pre>
posisi: 3 2 1 0
bit: 1 1 1 1
nilai tempat: 8 4 2 1
sumbangan: 8 4 2 1
</pre>

Hitung: 8 + 4 + 2 + 1 = '''15'''

=== Ringkasan keempatnya ===

{| class="wikitable"
! Vektor bit !! Perhitungan !! Hasil
|-
| <code>[0001]</code> || 0 + 0 + 0 + 1 || 1
|-
| <code>[0101]</code> || 0 + 4 + 0 + 1 || 5
|-
| <code>[1011]</code> || 8 + 0 + 2 + 1 || 11
|-
| <code>[1111]</code> || 8 + 4 + 2 + 1 || 15
|}

== Langkah 6: Cara membaca Figure 2.12 ==

Gambar di buku itu sebenarnya cuma cara lain menyajikan tabel di atas.

Tiap posisi bit digambar sebagai '''batang biru''' yang panjangnya sesuai nilai tempatnya:

<pre>
2^3 = 8 |========================|
2^2 = 4 |============|
2^1 = 2 |======|
2^0 = 1 |===|

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
</pre>

Lalu tiap vektor bit digambar dengan '''menyambung batang-batang yang bitnya bernilai 1''':

<pre>
[0001] |===| -> 1
[0101] |============|===| -> 5
[1011] |========================|======|===| -> 11
[1111] |========================|============|======|===| -> 15
</pre>

Jadi nilai sebuah vektor bit sama dengan '''total panjang batang yang tersambung'''. Gambar itu adalah cara menunjukkan penjumlahan tanpa menulis penjumlahan.

= Bagian 3: Rentang nilainya =

== Langkah 7: Yang terkecil dan yang terbesar ==

=== Nilai terkecil ===

Semua saklar mati:

<pre>
[0000] -> 0 + 0 + 0 + 0 = 0
</pre>

Jadi nilai terkecil selalu '''0'''. Tidak ada cara membuatnya lebih kecil, karena tidak ada bit yang bisa menyumbang nilai negatif.

=== Nilai terbesar ===

Semua saklar menyala:

<pre>
[1111] -> 8 + 4 + 2 + 1 = 15
</pre>

Buku memberi nama untuk nilai terbesar ini: '''UMax_w'''.

Untuk w = 4:

<pre>
UMax_4 = 2^4 - 1 = 16 - 1 = 15
</pre>

Rumus umumnya:

<pre>
UMax_w = 2^w - 1
</pre>

=== Kenapa dikurangi satu ===

Ini pertanyaan yang wajar dan jawabannya sederhana.

Dengan w bit, ada '''2^w pola bit''' yang mungkin. Untuk w = 4 berarti ada 16 pola: dari <code>[0000]</code> sampai <code>[1111]</code>.

Tapi kita mulai menghitung dari '''0''', bukan dari 1. Jadi:

<pre>
pola ke-1 -> 0
pola ke-2 -> 1
pola ke-3 -> 2
...
pola ke-16 -> 15
</pre>

Enam belas pola, tapi angka terbesarnya 15. Karena satu jatah terpakai untuk angka nol.

{{Tip|Analogi: kalau ada 16 kursi bernomor dan penomoran dimulai dari 0, kursi terakhir bernomor 15, bukan 16. Jumlah kursi dan nomor kursi terakhir memang selalu beda satu.}}

=== Tabel untuk lebar yang umum dipakai ===

{| class="wikitable"
! w !! Banyak pola (2^w) !! UMax_w !! Tipe C yang biasa
|-
| 4 || 16 || 15 || (nibble)
|-
| 8 || 256 || 255 || <code>unsigned char</code> / <code>uint8_t</code>
|-
| 16 || 65.536 || 65.535 || <code>uint16_t</code>
|-
| 32 || 4.294.967.296 || 4.294.967.295 || <code>unsigned int</code> / <code>uint32_t</code>
|-
| 64 || sekitar 1,8 x 10^19 || 2^64 - 1 || <code>uint64_t</code>
|}

=== Cara menuliskannya secara formal ===

Dengan kedua batas itu, fungsi B2U bisa dinyatakan sebagai pemetaan:

<pre>
B2U : {0,1}^w -> {0, 1, 2, ... , UMax_w}
w
</pre>

Dibaca: "B2U mengambil masukan berupa deretan w buah angka 0-atau-1, dan menghasilkan keluaran berupa satu bilangan antara 0 sampai UMax_w."

= Bagian 4: Arah sebaliknya dan sifat bijection =

== Langkah 8: Dari angka kembali ke bit ==

Kita sudah bisa jalan dari bit ke angka. Sekarang arah baliknya.

Fungsi kebalikan ini dinamai '''U2B_w''' (''unsigned to binary'').

=== Cara mengerjakannya: metode kurangi dari yang terbesar ===

Misal kita mau menulis '''11''' dalam 4 bit.

'''Langkah A.''' Tulis nilai tempatnya: 8, 4, 2, 1

'''Langkah B.''' Mulai dari yang terbesar. Tanya: "apakah 8 muat di dalam 11?"

<pre>
8 muat di 11? Ya. -> bit posisi 3 = 1
Sisa: 11 - 8 = 3
</pre>

'''Langkah C.''' Lanjut ke 4.

<pre>
4 muat di 3? Tidak. -> bit posisi 2 = 0
Sisa tetap: 3
</pre>

'''Langkah D.''' Lanjut ke 2.

<pre>
2 muat di 3? Ya. -> bit posisi 1 = 1
Sisa: 3 - 2 = 1
</pre>

'''Langkah E.''' Lanjut ke 1.

<pre>
1 muat di 1? Ya. -> bit posisi 0 = 1
Sisa: 1 - 1 = 0
</pre>

'''Hasil:''' <code>[1011]</code>. Sisanya nol, berarti pas.

'''Cek balik:''' 8 + 0 + 2 + 1 = 11 ✓

== Langkah 9: Sifat bijection ==

Sekarang bagian yang paling penting di section ini — dan yang paling gampang dilewat karena kelihatannya cuma teori.

Buku menyatakan sebuah prinsip: '''fungsi B2U_w adalah bijection'''.

=== Apa itu bijection ===

Istilah matematika untuk fungsi yang '''jalan dua arah dengan rapi'''. Definisi dari buku: fungsi f yang memetakan nilai x ke nilai y, dan bisa juga bekerja terbalik, karena untuk setiap y ada tepat satu x yang menghasilkannya.

Dalam konteks kita, artinya dua jaminan sekaligus:

; Jaminan 1: Tidak ada angka yang punya dua penulisan
: Angka 11 dalam 4 bit hanya bisa ditulis satu cara: <code>[1011]</code>. Tidak ada pola bit lain yang juga berarti 11.

; Jaminan 2: Tidak ada pola bit yang tidak berarti apa-apa
: Semua 16 pola pada w = 4 adalah angka yang sah. Tidak ada pola yang terbuang, ilegal, atau tanpa makna.

=== Analogi sederhana ===

Bayangkan sebuah kamus dua bahasa yang sempurna:

* tiap kata di bahasa A punya '''tepat satu''' terjemahan di bahasa B
* tiap kata di bahasa B punya '''tepat satu''' terjemahan balik di bahasa A
* '''tidak ada''' kata yang tidak kebagian pasangan
* '''tidak ada''' kata yang punya dua arti

Kamus semacam itulah yang disebut bijection. Dan itulah hubungan antara pola bit dan bilangan tak-negatif.

<pre>
Pola bit Bilangan
(16 pola) (0 sampai 15)

[0000] <------------------> 0
[0001] <------------------> 1
[0010] <------------------> 2
... ...
[1111] <------------------> 15

Tidak ada yang menyilang, tidak ada yang menggantung.
</pre>

=== Kenapa jaminan ini perlu disebut ===

Karena sifat ini '''tidak otomatis'''. Ada cara pengkodean lain yang justru gagal memenuhinya.

Contohnya '''sign-magnitude''', yaitu skema di mana bit paling kiri dipakai sebagai tanda. Di skema itu:

<pre>
[0000] -> +0
[1000] -> -0
</pre>

Dua pola bit yang berbeda, tapi artinya sama-sama nol. Jaminan 1 langsung gugur. Akibatnya membandingkan dua angka jadi rumit, karena harus ada penanganan khusus untuk kasus nol ganda.

{{Note|title=Ini foreshadowing|Buku sengaja menegaskan sifat bijection di sini, karena pertanyaan yang sama akan diajukan lagi untuk '''two's-complement''' di §2.2.3. Polanya: setiap kali sebuah encoding baru diperkenalkan, pertanyaan pertamanya selalu "apakah ini bijection?" Kalau ya, encoding itu bersih dan bisa dipakai. Kalau tidak, akan ada kasus khusus yang merepotkan selamanya.}}

= Bagian 5: Latihan mandiri =

Kerjakan dulu tanpa melihat jawaban. Semua memakai w = 4.

<pre>
1. [0110] = ?
2. [1100] = ?
3. [1010] = ?
4. [0111] = ?
5. Tulis 13 dalam 4 bit
6. Tulis 9 dalam 4 bit
7. Berapa UMax untuk w = 6?
8. Ada berapa pola bit yang mungkin untuk w = 6?
</pre>

== Jawaban ==

<pre>
1. [0110] = 0 + 4 + 2 + 0 = 6
2. [1100] = 8 + 4 + 0 + 0 = 12
3. [1010] = 8 + 0 + 2 + 0 = 10
4. [0111] = 0 + 4 + 2 + 1 = 7
5. 13 = 8 + 4 + 1 -> [1101]
6. 9 = 8 + 1 -> [1001]
7. UMax_6 = 2^6 - 1 = 63
8. 2^6 = 64 pola
</pre>

= Catatan untuk kerja systems =

* '''Sifat "tidak ada pola ilegal" adalah alasan overflow unsigned di C terdefinisi.''' Karena setiap hasil setelah dipotong ke w bit pasti jatuh ke pola bit yang sah, standar C bisa menyatakan dengan tegas bahwa hasilnya membungkus (''wrap'') secara modulo 2^w. Bandingkan dengan integer bertanda, yang overflow-nya justru dinyatakan sebagai ''undefined behavior''.
* '''UMax muncul terus di kode nyata.''' Nilai 255, 65535, dan 4294967295 bukan angka acak — semuanya UMax untuk lebar 8, 16, dan 32 bit. Begitu melihat angka-angka itu di log atau di debugger, biasanya ada operasi unsigned yang membungkus.
* '''Pengurangan unsigned adalah sumber bug klasik.''' Karena tidak ada nilai negatif dalam encoding ini, ekspresi seperti <code>0u - 1u</code> tidak menghasilkan minus satu melainkan UMax. Bug perbandingan seperti <code>for (unsigned i = n-1; i >= 0; i--)</code> tidak pernah berhenti, karena kondisi <code>i >= 0</code> selalu benar untuk tipe unsigned.
* '''Relevansi ke quantization.''' Rentang uint8 adalah 0 sampai UMax_8 = 255, tepat 256 level. Sifat bijection itulah yang membuat pemetaan bolak-balik antara nilai real dan level kuantisasi bersih: setiap level punya satu pola bit, dan setiap pola bit adalah level yang sah. Tidak ada pola terbuang yang perlu ditangani khusus.
* '''Lebar bit adalah parameter, bukan konstanta.''' Semua rumus di section ini memakai w. Kebiasaan berpikir dalam w, bukan dalam angka 32 atau 64, sangat membantu saat berpindah antara uint8, fp16, dan format kustom di pekerjaan akselerator.

= Istilah kunci =

; Bit vector
: Deretan bit; ditulis <code>x</code> bertanda panah untuk keseluruhan, atau <code>x_i</code> untuk bit di posisi ke-i.
; w
: Lebar, yaitu banyaknya bit dalam vektor.
; Nilai tempat
: Bobot sebuah posisi bit, yaitu 2 pangkat nomor posisinya.
; B2U_w
: Fungsi yang memetakan vektor bit selebar w menjadi bilangan tak-negatif.
; U2B_w
: Fungsi kebalikannya, memetakan bilangan menjadi pola bit.
; UMax_w
: Nilai terbesar yang bisa direpresentasikan, yaitu 2^w - 1.
; Bijection
: Fungsi yang berpasangan satu-satu dua arah; tidak ada nilai ganda dan tidak ada yang tidak terpasangkan.

Linux & Operating System

2026-09-08T02:56:15Z

SanzSkuy:

CS:APP 2 Intro

2026-09-05T03:48:51Z

SanzSkuy: Created page with "== Kenapa biner == Komputer modern menyimpan dan memproses informasi yang direpresentasikan sebagai '''sinyal bernilai dua'''. Digit biner sederhana inilah — '''bit''' — yang jadi dasar revolusi digital. === Sedikit sejarah desimal === Notasi desimal (basis 10) sudah dipakai lebih dari '''1.000 tahun''': * '''dikembangkan di India''' * '''disempurnakan matematikawan Arab''' pada abad ke-12 * '''dibawa ke Barat''' pada abad ke-13 oleh matematikawan Italia '''Leona..."

== Kenapa biner ==

Komputer modern menyimpan dan memproses informasi yang direpresentasikan sebagai '''sinyal bernilai dua'''. Digit biner sederhana inilah — '''bit''' — yang jadi dasar revolusi digital.

=== Sedikit sejarah desimal ===

Notasi desimal (basis 10) sudah dipakai lebih dari '''1.000 tahun''':

* '''dikembangkan di India'''
* '''disempurnakan matematikawan Arab''' pada abad ke-12
* '''dibawa ke Barat''' pada abad ke-13 oleh matematikawan Italia '''Leonardo Pisano''' (ca. 1170–1250), yang lebih dikenal sebagai '''Fibonacci'''

Notasi desimal terasa alami untuk manusia yang berjari sepuluh. Tapi '''nilai biner bekerja lebih baik untuk membangun mesin''' yang menyimpan dan memproses informasi.

=== Kenapa dua nilai lebih mudah dibuat ===

Sinyal bernilai dua gampang direpresentasikan, disimpan, dan ditransmisikan. Contoh dari buku:

* ada atau tidak adanya lubang pada kartu berlubang
* tegangan tinggi atau rendah pada sebuah kawat
* domain magnetik yang berorientasi searah atau berlawanan jarum jam

Rangkaian elektronik untuk menyimpan dan menghitung sinyal bernilai dua '''sangat sederhana dan andal'''. Karena itulah produsen bisa mengintegrasikan '''jutaan bahkan miliaran''' rangkaian semacam itu ke satu keping silikon.

{{Catatan|title=Poin yang sering terlewat|Biner dipilih bukan karena lebih "benar" secara matematis, tapi karena '''lebih gampang dibikin dan lebih tahan derau'''. Membedakan dua level tegangan jauh lebih andal daripada membedakan sepuluh level. Ini keputusan rekayasa, bukan keputusan matematika.}}

== Bit sendirian tidak berguna ==

Sebuah bit tunggal, berdiri sendiri, tidak banyak gunanya. Kekuatannya baru muncul ketika kita:

# '''mengelompokkan bit''', lalu
# '''menerapkan suatu penafsiran''' yang memberi makna pada pola-pola bit yang mungkin

Dengan dua langkah itu, kita bisa merepresentasikan '''elemen dari himpunan berhingga apa pun'''. Misalnya sistem bilangan biner untuk mengkodekan bilangan tak-negatif, atau kode karakter standar untuk mengkodekan huruf dan simbol.

Perhatikan bahwa '''maknanya tidak ada di dalam bit itu sendiri''' — makna datang dari penafsiran yang kita tempelkan. Pola bit yang sama persis bisa berarti bilangan, huruf, atau instruksi, tergantung cara kita membacanya.

== Tiga representasi bilangan ==

{| class="wikitable"
! Representasi !! Dasar !! Untuk apa
|-
| '''Unsigned''' || Notasi biner tradisional || Bilangan lebih besar atau sama dengan 0
|-
| '''Two's-complement''' || — || Cara paling umum merepresentasikan integer bertanda (positif maupun negatif)
|-
| '''Floating-point''' || Versi basis 2 dari notasi ilmiah || Bilangan real (secara aproksimasi)
|}

Komputer mengimplementasikan operasi aritmetika seperti penjumlahan dan perkalian pada ketiga representasi ini, mirip dengan operasi yang bersesuaian pada integer dan bilangan real.

== Overflow dan kejutannya ==

Representasi komputer memakai '''jumlah bit yang terbatas''', sehingga sebagian operasi bisa '''overflow''' ketika hasilnya terlalu besar untuk direpresentasikan. Ini bisa memberi hasil yang mengejutkan.

=== Contoh integer ===

Di kebanyakan komputer sekarang (yang memakai representasi 32-bit untuk tipe <code>int</code>):

<pre>
200 * 300 * 400 * 500 = -884.901.888
</pre>

Perkalian sekumpulan bilangan '''positif''' menghasilkan bilangan '''negatif'''. Ini bertentangan dengan sifat aritmetika integer yang kita kenal.

=== Tapi konsisten ===

Meski begitu, aritmetika integer komputer '''tetap memenuhi banyak sifat''' aritmetika integer sejati. Perkalian tetap '''asosiatif dan komutatif''', sehingga semua ekspresi berikut menghasilkan angka yang sama, −884.901.888:

<pre>
(500 * 400) * (300 * 200)
((500 * 400) * 300) * 200
((200 * 500) * 300) * 400
400 * (200 * (300 * 500))
</pre>

Kalimat penutup bukunya pantas dikutip: komputer mungkin tidak menghasilkan hasil yang diharapkan, '''tapi setidaknya konsisten'''.

== Floating point punya penyakit yang berbeda ==

Aritmetika floating-point punya sifat matematis yang '''sama sekali berbeda'''.

* Hasil kali sekumpulan bilangan positif '''selalu positif''' — meski overflow akan menghasilkan nilai khusus '''+∞'''.
* Tapi aritmetika floating-point '''tidak asosiatif''', akibat presisi representasinya yang terbatas.

Contoh dari buku:

<pre>
(3.14 + 1e20) - 1e20 -> 0.0 di kebanyakan mesin
3.14 + (1e20 - 1e20) -> 3.14
</pre>

Cuma letak kurungnya yang dipindah, hasilnya berbeda total. Penyebabnya: saat 3.14 dijumlahkan ke 1e20, nilainya terlalu kecil untuk memengaruhi digit-digit signifikan yang tersedia, sehingga hilang dibulatkan.

{{Warning|title=Dua penyakit yang berbeda|Integer bisa memberi hasil '''salah tapi konsisten''' — urutan operasi tidak mengubah apa pun. Floating point memberi hasil '''hampir benar tapi bergantung urutan'''. Jangan menyamakan strategi menghadapi keduanya.}}

== Akar dari semua perbedaan itu ==

Sifat matematis integer dan floating-point berbeda karena '''cara keduanya menangani keterbatasan representasinya''':

{| class="wikitable"
! !! Rentang !! Ketepatan
|-
| '''Integer''' || relatif '''kecil''' || '''presisi''' (tepat)
|-
| '''Floating-point''' || '''luas''' || hanya '''aproksimasi'''
|}

Satu kalimat ini adalah inti seluruh Bab 2. Semua keanehan di sisa bab — overflow, pembulatan, kehilangan presisi — adalah konsekuensi dari trade-off ini.

{{Catatan|title=Relevansi ke quantization|Trade-off rentang lawan presisi inilah keputusan inti setiap kali memilih format numerik untuk inferensi model. fp32 punya rentang luas dan presisi memadai tapi mahal; fp16 mempersempit rentang; bf16 mempertahankan rentang fp32 tapi memangkas presisi; int8 membuang rentang dinamis sepenuhnya demi ketepatan pada skala tetap. Semuanya adalah titik-titik berbeda pada tabel di atas.}}

== Kenapa ini penting dipelajari ==

Buku menyebut beberapa alasan:

* '''Kebenaran program.''' Memahami rentang nilai yang bisa direpresentasikan dan sifat operasinya penting untuk menulis program yang bekerja benar '''pada seluruh rentang nilai numerik'''.
* '''Portabilitas.''' Agar program tetap benar di berbagai kombinasi mesin, operating system, dan compiler.
* '''Keamanan.''' Sejumlah kerentanan keamanan komputer '''muncul dari kehalusan aritmetika komputer'''. Dulu bug program cuma merepotkan orang saat kebetulan terpicu; sekarang ada banyak sekali penyerang yang mencoba mengeksploitasi bug apa pun untuk mendapat akses tak sah ke sistem orang lain. Ini menaruh kewajiban lebih tinggi pada programmer untuk memahami cara programnya bekerja '''dan cara program itu bisa dibuat berperilaku tidak diinginkan'''.
* '''Prasyarat Bab 3.''' Representasi ini harus dikenal sebelum masuk pemrograman tingkat mesin.
* '''Memahami output compiler.''' Buku menurunkan beberapa cara melakukan operasi aritmetika dengan langsung memanipulasi representasi tingkat bit. Teknik ini penting untuk memahami kode tingkat mesin yang dihasilkan compiler saat berusaha mengoptimalkan evaluasi ekspresi aritmetika.

== Pendekatan buku ==

Pembahasan bab ini berbasis '''seperangkat prinsip matematis inti'''. Alurnya:

# mulai dari '''definisi dasar''' encoding
# turunkan sifat-sifatnya: '''rentang bilangan''' yang bisa direpresentasikan, '''representasi tingkat bit'''-nya, dan '''sifat operasi aritmetika'''

Buku sengaja memakai sudut pandang abstrak ini, karena programmer perlu punya pemahaman jelas tentang bagaimana aritmetika komputer berhubungan dengan aritmetika integer dan real yang lebih familiar.

== Catatan tentang bahasa lain ==

{| class="wikitable"
! Bahasa !! Hubungannya
|-
| '''C++''' || Dibangun di atas C, memakai '''representasi dan operasi numerik yang persis sama'''. Semua yang dikatakan tentang C di bab ini berlaku juga untuk C++.
|-
| '''Java''' || Membuat '''seperangkat standar baru'''. Standar C dirancang untuk memungkinkan '''rentang implementasi yang luas''', sedangkan standar Java '''sangat spesifik''' soal format dan encoding data.
|}

== Catatan untuk kerja systems ==

* '''"Konsisten" itu benar di level hardware, tapi bukan jaminan di level bahasa C.''' Standar C menyatakan overflow pada integer '''bertanda''' sebagai ''undefined behavior'', sehingga compiler boleh mengasumsikan hal itu tidak pernah terjadi dan mengoptimalkan berdasarkan asumsi itu. Overflow pada integer '''tak bertanda''' terdefinisi dan membungkus (''wrap''). Gunakan <code>-fwrapv</code> bila memang menginginkan perilaku membungkus, atau <code>-fsanitize=undefined</code> untuk mendeteksinya saat pengujian.
* '''Rust memilih sikap berbeda.''' Overflow integer memicu panic pada build debug dan membungkus pada build release. Kalau perilakunya ingin eksplisit, tersedia <code>wrapping_mul</code>, <code>checked_mul</code>, <code>saturating_mul</code>, dan <code>overflowing_mul</code>. Pilihan eksplisit ini menghilangkan seluruh kelas ambiguitas yang ada di C.
* '''Non-asosiativitas floating point punya konsekuensi langsung pada komputasi paralel.''' Reduksi penjumlahan yang dipecah ke sejumlah thread menjumlahkan dalam urutan berbeda, sehingga hasilnya bisa berbeda saat jumlah thread diubah. Inilah sebabnya hasil pelatihan model bisa tidak reproducible antar konfigurasi, dan sebabnya ada mode reduksi deterministik di banyak pustaka.
* '''<code>-ffast-math</code> mengizinkan compiler menganggap floating point asosiatif.''' Itu memang membuka peluang vektorisasi dan penyusunan ulang, tapi sekaligus melanggar jaminan IEEE 754. Berguna untuk sebagian beban kerja, berbahaya untuk kode numerik yang sensitif — dan keputusan ini sebaiknya diambil sadar, bukan diwarisi dari <code>-Ofast</code>.
* '''Overflow integer adalah pintu masuk klasik kerentanan keamanan.''' Pola paling umum: menghitung ukuran buffer lewat perkalian, hasilnya overflow menjadi angka kecil, alokasi jadi terlalu kecil, lalu penulisan berikutnya meluber. Ini persis "kehalusan aritmetika komputer" yang disinggung buku.

{{Tip|Cara cepat membuktikan sendiri contoh di atas: kompilasi program kecil berisi <code>printf("%d\n", 200*300*400*500);</code> lalu bandingkan dengan <code>printf("%f\n", (3.14+1e20)-1e20);</code>. Dua baris itu meringkas seluruh pengantar bab ini.}}

== Istilah kunci ==

; Bit
: Digit biner; sinyal bernilai dua yang jadi dasar penyimpanan dan pemrosesan informasi.
; Encoding
: Penafsiran yang diterapkan pada sekelompok bit sehingga pola bit punya makna.
; Unsigned encoding
: Representasi berbasis notasi biner tradisional untuk bilangan tak-negatif.
; Two's-complement encoding
: Cara paling umum merepresentasikan integer bertanda.
; Floating-point encoding
: Versi basis 2 dari notasi ilmiah untuk merepresentasikan bilangan real secara aproksimasi.
; Overflow
: Keadaan ketika hasil operasi terlalu besar untuk direpresentasikan oleh jumlah bit yang tersedia.

Linux & Operating System

2026-09-05T03:48:18Z

SanzSkuy:

== Linux ==
* [[Cara install Arch Linux]]
* [[Linux from Scratch]]
* [[Install Arch Linux ARM di QEMU]]
* [[Bluetooth di Arch Linux (Pairing TWS)]]
* [[CUE 1.0]]

== Computer Systems ==
* [[Cara Kerja Floating Point]]
* [[Introduction to Assembly|Assembly Course]]
* [[Tahap-tahap dari source code menjadi executable file]]
* [[OS Manages Hardware]]
* [[Concurrency & Parallelism]]

=== Representing and Manipulating Information ===
* [[CS:APP 2 Intro]]

== LLVM ==
* [[llvm: cara install]]

Concurrency & Parallelism

2026-09-05T02:54:25Z

SanzSkuy:

== Dua tuntutan abadi ==

Sepanjang sejarah komputer digital, ada dua tuntutan yang jadi pendorong tetap perbaikan:

# kita ingin komputer '''melakukan lebih banyak'''
# kita ingin komputer '''berjalan lebih cepat'''

Keduanya membaik ketika processor '''mengerjakan lebih banyak hal sekaligus'''.

== Concurrency vs parallelism ==

Ini definisi yang wajib dipegang, dan bukunya memisahkan keduanya dengan tegas:

; Concurrency
: Konsep umum tentang '''sistem dengan banyak aktivitas yang simultan'''.
; Parallelism
: '''Penggunaan concurrency untuk membuat sistem berjalan lebih cepat'''.

{{Warning|title=Bukan sinonim, bukan juga lawan|Parallelism adalah ''bagian dari'' concurrency, bukan istilah sejajar. Concurrency menjawab pertanyaan "apakah sistem mengurus banyak hal sekaligus", parallelism menjawab "apakah keserentakan itu dipakai untuk mempercepat". Sistem bisa concurrent tanpa parallel — misalnya uniprocessor yang bergantian antar process.}}

Parallelism bisa dimanfaatkan pada '''beberapa tingkat abstraksi'''. Buku menyoroti tiga, dari yang tertinggi ke terendah:

{| class="wikitable"
! Tingkat !! Siapa yang mengatur
|-
| Thread-level concurrency || Programmer dan OS
|-
| Instruction-level parallelism || Hardware, otomatis
|-
| SIMD parallelism || Programmer dan compiler ||
|}

= Thread-Level Concurrency =

== Dari process ke thread ==

Berdiri di atas abstraksi [[process|process]], kita bisa merancang sistem tempat '''beberapa program berjalan pada saat yang sama'''. Dengan [[Threads|thread]], kita bahkan bisa punya '''beberapa alur kontrol di dalam satu process'''.

Dukungan untuk eksekusi concurrent sudah ada sejak munculnya '''time-sharing di awal 1960-an'''. Secara tradisional, eksekusi concurrent itu cuma '''disimulasikan''' — satu komputer berpindah cepat di antara process-process yang sedang berjalan, seperti pemain sulap yang menjaga beberapa bola tetap melayang di udara.

Bentuk concurrency ini memungkinkan:

* '''banyak user berinteraksi dengan satu sistem sekaligus''' — misalnya banyak orang meminta halaman dari satu Web server
* '''satu user mengerjakan banyak tugas sekaligus''' — browser di satu jendela, word processor di jendela lain, sambil memutar musik

== Uniprocessor dan multiprocessor ==

Sampai belum lama ini, sebagian besar komputasi nyata dikerjakan '''satu processor''', meski processor itu harus bergantian antar tugas. Konfigurasi ini disebut '''uniprocessor system'''.

Ketika kita membangun sistem yang terdiri dari '''beberapa processor, semuanya di bawah kendali satu kernel operating system''', itu disebut '''multiprocessor system'''. Sistem seperti ini sudah tersedia untuk komputasi skala besar sejak '''1980-an''', tapi baru jadi umum belakangan berkat multi-core dan hyperthreading.

=== Taksonomi (Figure 1.16) ===

<pre>
+-------------------------------------------------------+
| All processors |
| |
| +------------------+ +-----------------------------+ |
| | | | Multiprocessors | |
| | Uniprocessors | | | |
| | | | +------------+ +---------+ | |
| | | | | Multi-core | | Hyper- | | |
| | | | | | | threaded| | |
| | | | +------------+ +---------+ | |
| +------------------+ +-----------------------------+ |
+-------------------------------------------------------+
</pre>

Perhatikan bahwa multi-core dan hyperthreaded '''dua-duanya masuk kategori multiprocessor''' — dan keduanya bisa ada bersamaan di satu chip.

== Multi-core processor ==

Multi-core processor punya '''beberapa CPU (disebut "core") yang diintegrasikan ke satu chip sirkuit terpadu'''.

=== Organisasi (Figure 1.17) ===

<pre>
Processor package
+---------------------------------------------------------+
| Core 0 Core 3 |
| +-------------------+ +----------------+ |
| | Regs | | Regs | |
| +---------+---------+ . . . +--------+-------+ |
| | L1 d-$ | L1 i-$ | | L1 d-$ | L1 i-$| |
| +---------+---------+ +--------+-------+ |
| | L2 unified cache | | L2 unified $ | |
| +-------------------+ +----------------+ |
| |
| +---------------------------------------------------+ |
| | L3 unified cache (dibagi semua core) | |
| +---------------------------------------------------+ |
+---------------------------------------------------------+
|
+------------------+
| Main memory |
+------------------+
</pre>

Yang perlu dibaca dari gambar ini:

* Chip contohnya punya '''empat core'''.
* Tiap core punya '''L1 dan L2 cache sendiri'''.
* '''L1 dipecah dua''': satu menampung instruksi yang baru diambil, satu menampung data.
* Core '''berbagi level cache yang lebih tinggi''' (L3) serta '''antarmuka ke main memory'''.

Pakar industri memperkirakan akan ada '''puluhan, dan akhirnya ratusan core''' dalam satu chip.

{{Catatan|title=Kenapa L1 dipecah, L2 tidak|L1 dipisah instruksi dan data supaya processor bisa mengambil instruksi dan mengakses data dalam siklus yang sama tanpa saling menunggu. Di level L2 ke atas tekanannya sudah tidak sebesar itu, jadi cukup satu cache terpadu (''unified'').}}

== Hyperthreading ==

'''Hyperthreading''', kadang disebut '''simultaneous multi-threading (SMT)''', adalah teknik yang memungkinkan '''satu CPU mengeksekusi beberapa alur kontrol'''.

Caranya: '''menduplikasi sebagian hardware CPU''' sambil tetap '''menyisakan satu salinan untuk bagian lainnya'''.

{| class="wikitable"
! Diduplikasi !! Tetap satu salinan
|-
| Program counter || Unit aritmetika floating-point
|-
| Register file || (dan unit eksekusi lain)
|}

Perbedaan kecepatannya dramatis:

* Processor konvensional butuh sekitar '''20.000 clock cycle''' untuk berpindah antar thread.
* Processor hyperthreaded memutuskan thread mana yang dieksekusi '''pada basis siklus per siklus'''.

Ini memungkinkan CPU memanfaatkan sumber daya pemrosesannya lebih baik. Contohnya: kalau satu thread harus menunggu data dimuat ke cache, CPU bisa lanjut mengeksekusi thread lain.

Contoh dari buku: '''Intel Core i7''' bisa menjalankan dua thread per core, sehingga sistem empat core sebenarnya mengeksekusi '''delapan thread secara paralel'''.

{{Warning|title=Thread software vs thread hardware|Kata "thread" di sini berbeda makna dengan thread di [[Threads|§1.7.2]]. Thread di §1.7.2 adalah konsep OS yang dibuat programmer dan jumlahnya dinamis. Thread di hyperthreading adalah konsep hardware — set register dan PC yang diduplikasi di silikon, jumlahnya tetap dari pabrik. Analoginya: thread hardware adalah ''kursi'', thread software adalah ''orang yang duduk''. Inilah kenapa <code>nproc</code> di mesin 8 core melaporkan 16.}}

== Dua cara multiprocessing meningkatkan performa ==

# '''Mengurangi kebutuhan menyimulasikan concurrency''' saat mengerjakan banyak tugas. Bahkan komputer pribadi dengan satu pengguna tetap diharapkan melakukan banyak aktivitas sekaligus.
# '''Menjalankan satu program aplikasi lebih cepat''' — '''tapi hanya jika''' program itu dinyatakan dalam bentuk beberapa thread yang bisa benar-benar dieksekusi secara paralel.

Syarat pada poin kedua itu penting. Menambah core '''tidak otomatis''' mempercepat program yang ditulis single-threaded.

Prinsip concurrency sudah dirumuskan dan dipelajari lebih dari '''50 tahun''', tapi kehadiran sistem multi-core dan hyperthreaded sangat meningkatkan kebutuhan menemukan cara menulis program yang bisa memanfaatkan '''thread-level parallelism''' yang disediakan hardware.

= Instruction-Level Parallelism =

Pada tingkat abstraksi yang jauh lebih rendah, processor modern bisa '''mengeksekusi beberapa instruksi sekaligus'''. Sifat ini disebut '''instruction-level parallelism (ILP)'''.

Perbandingan angkanya:

{| class="wikitable"
! Processor !! Laju eksekusi
|-
| Intel 8086 (1978) || butuh '''3–10 clock cycle''' untuk '''satu''' instruksi
|-
| Processor modern || mempertahankan '''2–4 instruksi per clock cycle'''
|}

Yang mengejutkan: instruksi mana pun tetap butuh '''20 siklus atau lebih''' dari awal sampai selesai. Processor cuma memakai berbagai trik cerdas untuk '''memproses sampai 100 instruksi sekaligus''' dalam berbagai tahap penyelesaian.

== Pipelining ==

Dibahas di '''Bab 4'''. Idenya: tindakan yang dibutuhkan untuk mengeksekusi sebuah instruksi '''dipartisi jadi beberapa langkah''', dan hardware processor disusun sebagai '''rangkaian stage''', masing-masing mengerjakan satu langkah.

Stage-stage itu bisa '''beroperasi paralel''', mengerjakan bagian berbeda dari instruksi yang berbeda. Desain hardware yang cukup sederhana pun bisa mempertahankan laju eksekusi mendekati '''1 instruksi per clock cycle'''.

== Superscalar ==

Processor yang bisa mempertahankan laju eksekusi '''lebih cepat dari 1 instruksi per siklus''' disebut '''superscalar'''. Sebagian besar processor modern mendukung operasi superscalar.

Bab 5 menjelaskan model tingkat tinggi processor semacam ini — dan poin pentingnya: '''programmer aplikasi bisa memakai model itu untuk memahami performa programnya''', lalu menulis program supaya kode yang dihasilkan mencapai ILP lebih tinggi dan berjalan lebih cepat.

{{Catatan|ILP berjalan '''otomatis tanpa diminta'''. Programmer tidak menulis kode khusus untuk mengaktifkannya. Tapi programmer ''bisa'' menulis kode yang menghalanginya — misalnya rantai ketergantungan data yang panjang atau cabang yang sulit diprediksi.}}

= SIMD Parallelism =

Pada tingkat terendah, banyak processor modern punya hardware khusus yang memungkinkan '''satu instruksi menyebabkan beberapa operasi dilakukan secara paralel'''. Mode ini disebut '''single-instruction, multiple-data (SIMD) parallelism'''.

Contoh dari buku: generasi terbaru processor Intel dan AMD punya instruksi yang bisa '''menjumlahkan 8 pasang bilangan floating-point presisi tunggal''' (tipe data C <code>float</code>) secara paralel.

Instruksi SIMD ini '''terutama disediakan untuk mempercepat aplikasi yang memproses data gambar, suara, dan video'''.

== Cara memakainya ==

* Sebagian compiler '''berusaha mengekstrak SIMD secara otomatis''' dari program C.
* Metode yang '''lebih andal''' adalah menulis program memakai '''tipe data vector khusus''' yang didukung compiler seperti <code>gcc</code>.

Gaya pemrograman ini dijelaskan di Web Aside <code>opt:simd</code>, sebagai pelengkap pembahasan optimasi program di Bab 5.

= Catatan untuk kerja systems =

* '''Tiga level itu berlipat, bukan bergantian.''' Program yang dioptimalkan baik memanfaatkan ketiganya sekaligus: beberapa thread di beberapa core, tiap thread memanfaatkan superscalar, tiap instruksi memproses banyak elemen lewat SIMD. Faktor percepatannya berkalian.
* '''Auto-vectorization butuh diverifikasi, jangan diasumsikan.''' Di GCC dan Clang, <code>-O3 -march=native</code> mengaktifkan vektorisasi otomatis, tapi hasilnya sering gagal karena ''pointer aliasing'' atau alur kontrol di dalam loop. Cek dengan <code>-fopt-info-vec-missed</code> untuk melihat loop mana yang ditolak dan alasannya. Ini alasan buku menyebut menulis eksplisit lebih andal.
* '''SIMD sekarang jauh lebih lebar dari contoh di buku.''' Contoh "8 float sekaligus" itu setara AVX (256-bit). AVX-512 memproses 16 float sekaligus, dan ARM punya NEON serta SVE. Lebar vektor jadi parameter yang harus dipertimbangkan, bukan konstanta.
* '''Ukur IPC sebelum mengoptimalkan.''' <code>perf stat ./program</code> menampilkan ''instructions per cycle''. Angka di bawah 1 biasanya menandakan program terhambat memory atau salah prediksi cabang, bukan kekurangan compute — dan menambahkan SIMD ke program yang ''memory-bound'' tidak akan menolong.
* '''SMT bukan percepatan gratis.''' Dua thread hardware pada satu core berbagi unit eksekusi, L1, dan L2. Untuk beban kerja yang sering menunggu memory, SMT menguntungkan. Untuk beban kerja compute-bound padat seperti loop AVX, keduanya justru berebut sumber daya yang sama. Ini alasan SMT sering dimatikan di lingkungan HPC — keputusannya berdasarkan pengukuran, bukan preferensi.
* '''Hati-hati saat melakukan pinning.''' Karena satu core fisik menyumbang dua logical CPU, mem-''pin'' dua thread compute-heavy ke CPU 0 dan CPU 1 bisa saja berarti mengunci keduanya ke core fisik yang sama. Periksa topologi lebih dulu dengan <code>lscpu -e</code> atau <code>hwloc-ls</code>.
* '''Syarat pada poin kedua multiprocessing adalah inti Amdahl.''' Percepatan hanya datang dari bagian yang bisa diparalelkan. Bagian serial program menjadi batas atas yang tidak bisa dilewati berapa pun jumlah core yang ditambahkan.

{{Tip|Tiga perintah untuk melihat ketiga level sekaligus: <code>lscpu -e</code> untuk topologi thread-level, <code>perf stat -e instructions,cycles ./prog</code> untuk ILP, dan <code>objdump -d ./prog {{!}} grep -E 'vadd{{!}}vmul'</code> untuk memastikan instruksi SIMD benar-benar dihasilkan.}}

== Istilah kunci ==

; Concurrency
: Konsep umum sistem dengan banyak aktivitas simultan.
; Parallelism
: Penggunaan concurrency untuk membuat sistem berjalan lebih cepat.
; Uniprocessor system
: Sistem dengan satu processor yang bergantian antar tugas.
; Multiprocessor system
: Sistem dengan beberapa processor di bawah kendali satu kernel OS.
; Multi-core processor
: Beberapa CPU (core) yang diintegrasikan ke satu chip sirkuit terpadu.
; Hyperthreading
: Teknik yang memungkinkan satu CPU mengeksekusi beberapa alur kontrol dengan menduplikasi sebagian hardware seperti PC dan register file; disebut juga simultaneous multi-threading.
; Instruction-level parallelism
: Kemampuan processor mengeksekusi beberapa instruksi sekaligus.
; Pipelining
: Pembagian eksekusi instruksi jadi beberapa stage yang bisa beroperasi paralel.
; Superscalar
: Processor yang mempertahankan laju eksekusi lebih dari 1 instruksi per siklus.
; SIMD parallelism
: Mode ketika satu instruksi menyebabkan beberapa operasi dilakukan paralel.

== Lihat juga ==

* [[Process]]
* [[Threads]]
* [[Virtual Memory]]
* [[Files]]

Concurrency & Parallelism

2026-09-05T02:52:09Z

SanzSkuy:

== Dua tuntutan abadi ==

Sepanjang sejarah komputer digital, ada dua tuntutan yang jadi pendorong tetap perbaikan:

# kita ingin komputer '''melakukan lebih banyak'''
# kita ingin komputer '''berjalan lebih cepat'''

Keduanya membaik ketika processor '''mengerjakan lebih banyak hal sekaligus'''.

== Concurrency vs parallelism ==

Ini definisi yang wajib dipegang, dan bukunya memisahkan keduanya dengan tegas:

; Concurrency
: Konsep umum tentang '''sistem dengan banyak aktivitas yang simultan'''.
; Parallelism
: '''Penggunaan concurrency untuk membuat sistem berjalan lebih cepat'''.

{{Warning|title=Bukan sinonim, bukan juga lawan|Parallelism adalah ''bagian dari'' concurrency, bukan istilah sejajar. Concurrency menjawab pertanyaan "apakah sistem mengurus banyak hal sekaligus", parallelism menjawab "apakah keserentakan itu dipakai untuk mempercepat". Sistem bisa concurrent tanpa parallel — misalnya uniprocessor yang bergantian antar process.}}

Parallelism bisa dimanfaatkan pada '''beberapa tingkat abstraksi'''. Buku menyoroti tiga, dari yang tertinggi ke terendah:

{| class="wikitable"
! Tingkat !! Siapa yang mengatur
|-
| Thread-level concurrency || Programmer dan OS
|-
| Instruction-level parallelism || Hardware, otomatis
|-
| SIMD parallelism || Programmer dan compiler ||
|}

= Thread-Level Concurrency =

== Dari process ke thread ==

Berdiri di atas abstraksi [[process|process]], kita bisa merancang sistem tempat '''beberapa program berjalan pada saat yang sama'''. Dengan [[Threads|thread]], kita bahkan bisa punya '''beberapa alur kontrol di dalam satu process'''.

Dukungan untuk eksekusi concurrent sudah ada sejak munculnya '''time-sharing di awal 1960-an'''. Secara tradisional, eksekusi concurrent itu cuma '''disimulasikan''' — satu komputer berpindah cepat di antara process-process yang sedang berjalan, seperti pemain sulap yang menjaga beberapa bola tetap melayang di udara.

Bentuk concurrency ini memungkinkan:

* '''banyak user berinteraksi dengan satu sistem sekaligus''' — misalnya banyak orang meminta halaman dari satu Web server
* '''satu user mengerjakan banyak tugas sekaligus''' — browser di satu jendela, word processor di jendela lain, sambil memutar musik

== Uniprocessor dan multiprocessor ==

Sampai belum lama ini, sebagian besar komputasi nyata dikerjakan '''satu processor''', meski processor itu harus bergantian antar tugas. Konfigurasi ini disebut '''uniprocessor system'''.

Ketika kita membangun sistem yang terdiri dari '''beberapa processor, semuanya di bawah kendali satu kernel operating system''', itu disebut '''multiprocessor system'''. Sistem seperti ini sudah tersedia untuk komputasi skala besar sejak '''1980-an''', tapi baru jadi umum belakangan berkat multi-core dan hyperthreading.

=== Taksonomi (Figure 1.16) ===

<pre>
+-------------------------------------------------------+
| All processors |
| |
| +------------------+ +-----------------------------+ |
| | | | Multiprocessors | |
| | Uniprocessors | | | |
| | | | +------------+ +---------+ | |
| | | | | Multi-core | | Hyper- | | |
| | | | | | | threaded| | |
| | | | +------------+ +---------+ | |
| +------------------+ +-----------------------------+ |
+-------------------------------------------------------+
</pre>

Perhatikan bahwa multi-core dan hyperthreaded '''dua-duanya masuk kategori multiprocessor''' — dan keduanya bisa ada bersamaan di satu chip.

== Multi-core processor ==

Multi-core processor punya '''beberapa CPU (disebut "core") yang diintegrasikan ke satu chip sirkuit terpadu'''.

=== Organisasi (Figure 1.17) ===

<pre>
Processor package
+---------------------------------------------------------+
| Core 0 Core 3 |
| +-------------------+ +----------------+ |
| | Regs | | Regs | |
| +---------+---------+ . . . +--------+-------+ |
| | L1 d-$ | L1 i-$ | | L1 d-$ | L1 i-$| |
| +---------+---------+ +--------+-------+ |
| | L2 unified cache | | L2 unified $ | |
| +-------------------+ +----------------+ |
| |
| +---------------------------------------------------+ |
| | L3 unified cache (dibagi semua core) | |
| +---------------------------------------------------+ |
+---------------------------------------------------------+
|
+------------------+
| Main memory |
+------------------+
</pre>

Yang perlu dibaca dari gambar ini:

* Chip contohnya punya '''empat core'''.
* Tiap core punya '''L1 dan L2 cache sendiri'''.
* '''L1 dipecah dua''': satu menampung instruksi yang baru diambil, satu menampung data.
* Core '''berbagi level cache yang lebih tinggi''' (L3) serta '''antarmuka ke main memory'''.

Pakar industri memperkirakan akan ada '''puluhan, dan akhirnya ratusan core''' dalam satu chip.

{{Note|title=Kenapa L1 dipecah, L2 tidak|L1 dipisah instruksi dan data supaya processor bisa mengambil instruksi dan mengakses data dalam siklus yang sama tanpa saling menunggu. Di level L2 ke atas tekanannya sudah tidak sebesar itu, jadi cukup satu cache terpadu (''unified'').}}

== Hyperthreading ==

'''Hyperthreading''', kadang disebut '''simultaneous multi-threading (SMT)''', adalah teknik yang memungkinkan '''satu CPU mengeksekusi beberapa alur kontrol'''.

Caranya: '''menduplikasi sebagian hardware CPU''' sambil tetap '''menyisakan satu salinan untuk bagian lainnya'''.

{| class="wikitable"
! Diduplikasi !! Tetap satu salinan
|-
| Program counter || Unit aritmetika floating-point
|-
| Register file || (dan unit eksekusi lain)
|}

Perbedaan kecepatannya dramatis:

* Processor konvensional butuh sekitar '''20.000 clock cycle''' untuk berpindah antar thread.
* Processor hyperthreaded memutuskan thread mana yang dieksekusi '''pada basis siklus per siklus'''.

Ini memungkinkan CPU memanfaatkan sumber daya pemrosesannya lebih baik. Contohnya: kalau satu thread harus menunggu data dimuat ke cache, CPU bisa lanjut mengeksekusi thread lain.

Contoh dari buku: '''Intel Core i7''' bisa menjalankan dua thread per core, sehingga sistem empat core sebenarnya mengeksekusi '''delapan thread secara paralel'''.

{{Warning|title=Thread software vs thread hardware|Kata "thread" di sini berbeda makna dengan thread di [[Threads|§1.7.2]]. Thread di §1.7.2 adalah konsep OS yang dibuat programmer dan jumlahnya dinamis. Thread di hyperthreading adalah konsep hardware — set register dan PC yang diduplikasi di silikon, jumlahnya tetap dari pabrik. Analoginya: thread hardware adalah ''kursi'', thread software adalah ''orang yang duduk''. Inilah kenapa <code>nproc</code> di mesin 8 core melaporkan 16.}}

== Dua cara multiprocessing meningkatkan performa ==

# '''Mengurangi kebutuhan menyimulasikan concurrency''' saat mengerjakan banyak tugas. Bahkan komputer pribadi dengan satu pengguna tetap diharapkan melakukan banyak aktivitas sekaligus.
# '''Menjalankan satu program aplikasi lebih cepat''' — '''tapi hanya jika''' program itu dinyatakan dalam bentuk beberapa thread yang bisa benar-benar dieksekusi secara paralel.

Syarat pada poin kedua itu penting. Menambah core '''tidak otomatis''' mempercepat program yang ditulis single-threaded.

Prinsip concurrency sudah dirumuskan dan dipelajari lebih dari '''50 tahun''', tapi kehadiran sistem multi-core dan hyperthreaded sangat meningkatkan kebutuhan menemukan cara menulis program yang bisa memanfaatkan '''thread-level parallelism''' yang disediakan hardware.

= Instruction-Level Parallelism =

Pada tingkat abstraksi yang jauh lebih rendah, processor modern bisa '''mengeksekusi beberapa instruksi sekaligus'''. Sifat ini disebut '''instruction-level parallelism (ILP)'''.

Perbandingan angkanya:

{| class="wikitable"
! Processor !! Laju eksekusi
|-
| Intel 8086 (1978) || butuh '''3–10 clock cycle''' untuk '''satu''' instruksi
|-
| Processor modern || mempertahankan '''2–4 instruksi per clock cycle'''
|}

Yang mengejutkan: instruksi mana pun tetap butuh '''20 siklus atau lebih''' dari awal sampai selesai. Processor cuma memakai berbagai trik cerdas untuk '''memproses sampai 100 instruksi sekaligus''' dalam berbagai tahap penyelesaian.

== Pipelining ==

Dibahas di '''Bab 4'''. Idenya: tindakan yang dibutuhkan untuk mengeksekusi sebuah instruksi '''dipartisi jadi beberapa langkah''', dan hardware processor disusun sebagai '''rangkaian stage''', masing-masing mengerjakan satu langkah.

Stage-stage itu bisa '''beroperasi paralel''', mengerjakan bagian berbeda dari instruksi yang berbeda. Desain hardware yang cukup sederhana pun bisa mempertahankan laju eksekusi mendekati '''1 instruksi per clock cycle'''.

== Superscalar ==

Processor yang bisa mempertahankan laju eksekusi '''lebih cepat dari 1 instruksi per siklus''' disebut '''superscalar'''. Sebagian besar processor modern mendukung operasi superscalar.

Bab 5 menjelaskan model tingkat tinggi processor semacam ini — dan poin pentingnya: '''programmer aplikasi bisa memakai model itu untuk memahami performa programnya''', lalu menulis program supaya kode yang dihasilkan mencapai ILP lebih tinggi dan berjalan lebih cepat.

{{Note|ILP berjalan '''otomatis tanpa diminta'''. Programmer tidak menulis kode khusus untuk mengaktifkannya. Tapi programmer ''bisa'' menulis kode yang menghalanginya — misalnya rantai ketergantungan data yang panjang atau cabang yang sulit diprediksi.}}

= SIMD Parallelism =

Pada tingkat terendah, banyak processor modern punya hardware khusus yang memungkinkan '''satu instruksi menyebabkan beberapa operasi dilakukan secara paralel'''. Mode ini disebut '''single-instruction, multiple-data (SIMD) parallelism'''.

Contoh dari buku: generasi terbaru processor Intel dan AMD punya instruksi yang bisa '''menjumlahkan 8 pasang bilangan floating-point presisi tunggal''' (tipe data C <code>float</code>) secara paralel.

Instruksi SIMD ini '''terutama disediakan untuk mempercepat aplikasi yang memproses data gambar, suara, dan video'''.

== Cara memakainya ==

* Sebagian compiler '''berusaha mengekstrak SIMD secara otomatis''' dari program C.
* Metode yang '''lebih andal''' adalah menulis program memakai '''tipe data vector khusus''' yang didukung compiler seperti <code>gcc</code>.

Gaya pemrograman ini dijelaskan di Web Aside <code>opt:simd</code>, sebagai pelengkap pembahasan optimasi program di Bab 5.

= Catatan untuk kerja systems =

* '''Tiga level itu berlipat, bukan bergantian.''' Program yang dioptimalkan baik memanfaatkan ketiganya sekaligus: beberapa thread di beberapa core, tiap thread memanfaatkan superscalar, tiap instruksi memproses banyak elemen lewat SIMD. Faktor percepatannya berkalian.
* '''Auto-vectorization butuh diverifikasi, jangan diasumsikan.''' Di GCC dan Clang, <code>-O3 -march=native</code> mengaktifkan vektorisasi otomatis, tapi hasilnya sering gagal karena ''pointer aliasing'' atau alur kontrol di dalam loop. Cek dengan <code>-fopt-info-vec-missed</code> untuk melihat loop mana yang ditolak dan alasannya. Ini alasan buku menyebut menulis eksplisit lebih andal.
* '''SIMD sekarang jauh lebih lebar dari contoh di buku.''' Contoh "8 float sekaligus" itu setara AVX (256-bit). AVX-512 memproses 16 float sekaligus, dan ARM punya NEON serta SVE. Lebar vektor jadi parameter yang harus dipertimbangkan, bukan konstanta.
* '''Ukur IPC sebelum mengoptimalkan.''' <code>perf stat ./program</code> menampilkan ''instructions per cycle''. Angka di bawah 1 biasanya menandakan program terhambat memory atau salah prediksi cabang, bukan kekurangan compute — dan menambahkan SIMD ke program yang ''memory-bound'' tidak akan menolong.
* '''SMT bukan percepatan gratis.''' Dua thread hardware pada satu core berbagi unit eksekusi, L1, dan L2. Untuk beban kerja yang sering menunggu memory, SMT menguntungkan. Untuk beban kerja compute-bound padat seperti loop AVX, keduanya justru berebut sumber daya yang sama. Ini alasan SMT sering dimatikan di lingkungan HPC — keputusannya berdasarkan pengukuran, bukan preferensi.
* '''Hati-hati saat melakukan pinning.''' Karena satu core fisik menyumbang dua logical CPU, mem-''pin'' dua thread compute-heavy ke CPU 0 dan CPU 1 bisa saja berarti mengunci keduanya ke core fisik yang sama. Periksa topologi lebih dulu dengan <code>lscpu -e</code> atau <code>hwloc-ls</code>.
* '''Syarat pada poin kedua multiprocessing adalah inti Amdahl.''' Percepatan hanya datang dari bagian yang bisa diparalelkan. Bagian serial program menjadi batas atas yang tidak bisa dilewati berapa pun jumlah core yang ditambahkan.

{{Tip|Tiga perintah untuk melihat ketiga level sekaligus: <code>lscpu -e</code> untuk topologi thread-level, <code>perf stat -e instructions,cycles ./prog</code> untuk ILP, dan <code>objdump -d ./prog {{!}} grep -E 'vadd{{!}}vmul'</code> untuk memastikan instruksi SIMD benar-benar dihasilkan.}}

== Istilah kunci ==

; Concurrency
: Konsep umum sistem dengan banyak aktivitas simultan.
; Parallelism
: Penggunaan concurrency untuk membuat sistem berjalan lebih cepat.
; Uniprocessor system
: Sistem dengan satu processor yang bergantian antar tugas.
; Multiprocessor system
: Sistem dengan beberapa processor di bawah kendali satu kernel OS.
; Multi-core processor
: Beberapa CPU (core) yang diintegrasikan ke satu chip sirkuit terpadu.
; Hyperthreading
: Teknik yang memungkinkan satu CPU mengeksekusi beberapa alur kontrol dengan menduplikasi sebagian hardware seperti PC dan register file; disebut juga simultaneous multi-threading.
; Instruction-level parallelism
: Kemampuan processor mengeksekusi beberapa instruksi sekaligus.
; Pipelining
: Pembagian eksekusi instruksi jadi beberapa stage yang bisa beroperasi paralel.
; Superscalar
: Processor yang mempertahankan laju eksekusi lebih dari 1 instruksi per siklus.
; SIMD parallelism
: Mode ketika satu instruksi menyebabkan beberapa operasi dilakukan paralel.

== Lihat juga ==

* [[Process]]
* [[Threads]]
* [[Virtual Memory]]
* [[Files]]

Concurrency & Parallelism

2026-09-05T02:50:31Z

SanzSkuy: Created page with "== Dua tuntutan abadi == Sepanjang sejarah komputer digital, ada dua tuntutan yang jadi pendorong tetap perbaikan: # kita ingin komputer '''melakukan lebih banyak''' # kita ingin komputer '''berjalan lebih cepat''' Keduanya membaik ketika processor '''mengerjakan lebih banyak hal sekaligus'''. == Concurrency vs parallelism == Ini definisi yang wajib dipegang, dan bukunya memisahkan keduanya dengan tegas: ; Concurrency : Konsep umum tentang '''sistem dengan banyak a..."

== Dua tuntutan abadi ==

Sepanjang sejarah komputer digital, ada dua tuntutan yang jadi pendorong tetap perbaikan:

# kita ingin komputer '''melakukan lebih banyak'''
# kita ingin komputer '''berjalan lebih cepat'''

Keduanya membaik ketika processor '''mengerjakan lebih banyak hal sekaligus'''.

== Concurrency vs parallelism ==

Ini definisi yang wajib dipegang, dan bukunya memisahkan keduanya dengan tegas:

; Concurrency
: Konsep umum tentang '''sistem dengan banyak aktivitas yang simultan'''.
; Parallelism
: '''Penggunaan concurrency untuk membuat sistem berjalan lebih cepat'''.

{{Warning|title=Bukan sinonim, bukan juga lawan|Parallelism adalah ''bagian dari'' concurrency, bukan istilah sejajar. Concurrency menjawab pertanyaan "apakah sistem mengurus banyak hal sekaligus", parallelism menjawab "apakah keserentakan itu dipakai untuk mempercepat". Sistem bisa concurrent tanpa parallel — misalnya uniprocessor yang bergantian antar process.}}

Parallelism bisa dimanfaatkan pada '''beberapa tingkat abstraksi'''. Buku menyoroti tiga, dari yang tertinggi ke terendah:

{| class="wikitable"
! Tingkat !! Siapa yang mengatur !! Dibahas di
|-
| Thread-level concurrency || Programmer dan OS || Bab 12
|-
| Instruction-level parallelism || Hardware, otomatis || Bab 4 dan 5
|-
| SIMD parallelism || Programmer dan compiler || Bab 5 dan Web Aside
|}

= Thread-Level Concurrency =

== Dari process ke thread ==

Berdiri di atas abstraksi [[Processes|process]], kita bisa merancang sistem tempat '''beberapa program berjalan pada saat yang sama'''. Dengan [[Threads|thread]], kita bahkan bisa punya '''beberapa alur kontrol di dalam satu process'''.

Dukungan untuk eksekusi concurrent sudah ada sejak munculnya '''time-sharing di awal 1960-an'''. Secara tradisional, eksekusi concurrent itu cuma '''disimulasikan''' — satu komputer berpindah cepat di antara process-process yang sedang berjalan, seperti pemain sulap yang menjaga beberapa bola tetap melayang di udara.

Bentuk concurrency ini memungkinkan:

* '''banyak user berinteraksi dengan satu sistem sekaligus''' — misalnya banyak orang meminta halaman dari satu Web server
* '''satu user mengerjakan banyak tugas sekaligus''' — browser di satu jendela, word processor di jendela lain, sambil memutar musik

== Uniprocessor dan multiprocessor ==

Sampai belum lama ini, sebagian besar komputasi nyata dikerjakan '''satu processor''', meski processor itu harus bergantian antar tugas. Konfigurasi ini disebut '''uniprocessor system'''.

Ketika kita membangun sistem yang terdiri dari '''beberapa processor, semuanya di bawah kendali satu kernel operating system''', itu disebut '''multiprocessor system'''. Sistem seperti ini sudah tersedia untuk komputasi skala besar sejak '''1980-an''', tapi baru jadi umum belakangan berkat multi-core dan hyperthreading.

=== Taksonomi (Figure 1.16) ===

<pre>
+-------------------------------------------------------+
| All processors |
| |
| +------------------+ +-----------------------------+ |
| | | | Multiprocessors | |
| | Uniprocessors | | | |
| | | | +------------+ +---------+ | |
| | | | | Multi-core | | Hyper- | | |
| | | | | | | threaded| | |
| | | | +------------+ +---------+ | |
| +------------------+ +-----------------------------+ |
+-------------------------------------------------------+
</pre>

Perhatikan bahwa multi-core dan hyperthreaded '''dua-duanya masuk kategori multiprocessor''' — dan keduanya bisa ada bersamaan di satu chip.

== Multi-core processor ==

Multi-core processor punya '''beberapa CPU (disebut "core") yang diintegrasikan ke satu chip sirkuit terpadu'''.

=== Organisasi (Figure 1.17) ===

<pre>
Processor package
+---------------------------------------------------------+
| Core 0 Core 3 |
| +-------------------+ +----------------+ |
| | Regs | | Regs | |
| +---------+---------+ . . . +--------+-------+ |
| | L1 d-$ | L1 i-$ | | L1 d-$ | L1 i-$| |
| +---------+---------+ +--------+-------+ |
| | L2 unified cache | | L2 unified $ | |
| +-------------------+ +----------------+ |
| |
| +---------------------------------------------------+ |
| | L3 unified cache (dibagi semua core) | |
| +---------------------------------------------------+ |
+---------------------------------------------------------+
|
+------------------+
| Main memory |
+------------------+
</pre>

Yang perlu dibaca dari gambar ini:

* Chip contohnya punya '''empat core'''.
* Tiap core punya '''L1 dan L2 cache sendiri'''.
* '''L1 dipecah dua''': satu menampung instruksi yang baru diambil, satu menampung data.
* Core '''berbagi level cache yang lebih tinggi''' (L3) serta '''antarmuka ke main memory'''.

Pakar industri memperkirakan akan ada '''puluhan, dan akhirnya ratusan core''' dalam satu chip.

{{Note|title=Kenapa L1 dipecah, L2 tidak|L1 dipisah instruksi dan data supaya processor bisa mengambil instruksi dan mengakses data dalam siklus yang sama tanpa saling menunggu. Di level L2 ke atas tekanannya sudah tidak sebesar itu, jadi cukup satu cache terpadu (''unified'').}}

== Hyperthreading ==

'''Hyperthreading''', kadang disebut '''simultaneous multi-threading (SMT)''', adalah teknik yang memungkinkan '''satu CPU mengeksekusi beberapa alur kontrol'''.

Caranya: '''menduplikasi sebagian hardware CPU''' sambil tetap '''menyisakan satu salinan untuk bagian lainnya'''.

{| class="wikitable"
! Diduplikasi !! Tetap satu salinan
|-
| Program counter || Unit aritmetika floating-point
|-
| Register file || (dan unit eksekusi lain)
|}

Perbedaan kecepatannya dramatis:

* Processor konvensional butuh sekitar '''20.000 clock cycle''' untuk berpindah antar thread.
* Processor hyperthreaded memutuskan thread mana yang dieksekusi '''pada basis siklus per siklus'''.

Ini memungkinkan CPU memanfaatkan sumber daya pemrosesannya lebih baik. Contohnya: kalau satu thread harus menunggu data dimuat ke cache, CPU bisa lanjut mengeksekusi thread lain.

Contoh dari buku: '''Intel Core i7''' bisa menjalankan dua thread per core, sehingga sistem empat core sebenarnya mengeksekusi '''delapan thread secara paralel'''.

{{Warning|title=Thread software vs thread hardware|Kata "thread" di sini berbeda makna dengan thread di [[Threads|§1.7.2]]. Thread di §1.7.2 adalah konsep OS yang dibuat programmer dan jumlahnya dinamis. Thread di hyperthreading adalah konsep hardware — set register dan PC yang diduplikasi di silikon, jumlahnya tetap dari pabrik. Analoginya: thread hardware adalah ''kursi'', thread software adalah ''orang yang duduk''. Inilah kenapa <code>nproc</code> di mesin 8 core melaporkan 16.}}

== Dua cara multiprocessing meningkatkan performa ==

# '''Mengurangi kebutuhan menyimulasikan concurrency''' saat mengerjakan banyak tugas. Bahkan komputer pribadi dengan satu pengguna tetap diharapkan melakukan banyak aktivitas sekaligus.
# '''Menjalankan satu program aplikasi lebih cepat''' — '''tapi hanya jika''' program itu dinyatakan dalam bentuk beberapa thread yang bisa benar-benar dieksekusi secara paralel.

Syarat pada poin kedua itu penting. Menambah core '''tidak otomatis''' mempercepat program yang ditulis single-threaded.

Prinsip concurrency sudah dirumuskan dan dipelajari lebih dari '''50 tahun''', tapi kehadiran sistem multi-core dan hyperthreaded sangat meningkatkan kebutuhan menemukan cara menulis program yang bisa memanfaatkan '''thread-level parallelism''' yang disediakan hardware.

= Instruction-Level Parallelism =

Pada tingkat abstraksi yang jauh lebih rendah, processor modern bisa '''mengeksekusi beberapa instruksi sekaligus'''. Sifat ini disebut '''instruction-level parallelism (ILP)'''.

Perbandingan angkanya:

{| class="wikitable"
! Processor !! Laju eksekusi
|-
| Intel 8086 (1978) || butuh '''3–10 clock cycle''' untuk '''satu''' instruksi
|-
| Processor modern || mempertahankan '''2–4 instruksi per clock cycle'''
|}

Yang mengejutkan: instruksi mana pun tetap butuh '''20 siklus atau lebih''' dari awal sampai selesai. Processor cuma memakai berbagai trik cerdas untuk '''memproses sampai 100 instruksi sekaligus''' dalam berbagai tahap penyelesaian.

== Pipelining ==

Dibahas di '''Bab 4'''. Idenya: tindakan yang dibutuhkan untuk mengeksekusi sebuah instruksi '''dipartisi jadi beberapa langkah''', dan hardware processor disusun sebagai '''rangkaian stage''', masing-masing mengerjakan satu langkah.

Stage-stage itu bisa '''beroperasi paralel''', mengerjakan bagian berbeda dari instruksi yang berbeda. Desain hardware yang cukup sederhana pun bisa mempertahankan laju eksekusi mendekati '''1 instruksi per clock cycle'''.

== Superscalar ==

Processor yang bisa mempertahankan laju eksekusi '''lebih cepat dari 1 instruksi per siklus''' disebut '''superscalar'''. Sebagian besar processor modern mendukung operasi superscalar.

Bab 5 menjelaskan model tingkat tinggi processor semacam ini — dan poin pentingnya: '''programmer aplikasi bisa memakai model itu untuk memahami performa programnya''', lalu menulis program supaya kode yang dihasilkan mencapai ILP lebih tinggi dan berjalan lebih cepat.

{{Note|ILP berjalan '''otomatis tanpa diminta'''. Programmer tidak menulis kode khusus untuk mengaktifkannya. Tapi programmer ''bisa'' menulis kode yang menghalanginya — misalnya rantai ketergantungan data yang panjang atau cabang yang sulit diprediksi.}}

= SIMD Parallelism =

Pada tingkat terendah, banyak processor modern punya hardware khusus yang memungkinkan '''satu instruksi menyebabkan beberapa operasi dilakukan secara paralel'''. Mode ini disebut '''single-instruction, multiple-data (SIMD) parallelism'''.

Contoh dari buku: generasi terbaru processor Intel dan AMD punya instruksi yang bisa '''menjumlahkan 8 pasang bilangan floating-point presisi tunggal''' (tipe data C <code>float</code>) secara paralel.

Instruksi SIMD ini '''terutama disediakan untuk mempercepat aplikasi yang memproses data gambar, suara, dan video'''.

== Cara memakainya ==

* Sebagian compiler '''berusaha mengekstrak SIMD secara otomatis''' dari program C.
* Metode yang '''lebih andal''' adalah menulis program memakai '''tipe data vector khusus''' yang didukung compiler seperti <code>gcc</code>.

Gaya pemrograman ini dijelaskan di Web Aside <code>opt:simd</code>, sebagai pelengkap pembahasan optimasi program di Bab 5.

= Catatan untuk kerja systems =

* '''Tiga level itu berlipat, bukan bergantian.''' Program yang dioptimalkan baik memanfaatkan ketiganya sekaligus: beberapa thread di beberapa core, tiap thread memanfaatkan superscalar, tiap instruksi memproses banyak elemen lewat SIMD. Faktor percepatannya berkalian.
* '''Auto-vectorization butuh diverifikasi, jangan diasumsikan.''' Di GCC dan Clang, <code>-O3 -march=native</code> mengaktifkan vektorisasi otomatis, tapi hasilnya sering gagal karena ''pointer aliasing'' atau alur kontrol di dalam loop. Cek dengan <code>-fopt-info-vec-missed</code> untuk melihat loop mana yang ditolak dan alasannya. Ini alasan buku menyebut menulis eksplisit lebih andal.
* '''SIMD sekarang jauh lebih lebar dari contoh di buku.''' Contoh "8 float sekaligus" itu setara AVX (256-bit). AVX-512 memproses 16 float sekaligus, dan ARM punya NEON serta SVE. Lebar vektor jadi parameter yang harus dipertimbangkan, bukan konstanta.
* '''Ukur IPC sebelum mengoptimalkan.''' <code>perf stat ./program</code> menampilkan ''instructions per cycle''. Angka di bawah 1 biasanya menandakan program terhambat memory atau salah prediksi cabang, bukan kekurangan compute — dan menambahkan SIMD ke program yang ''memory-bound'' tidak akan menolong.
* '''SMT bukan percepatan gratis.''' Dua thread hardware pada satu core berbagi unit eksekusi, L1, dan L2. Untuk beban kerja yang sering menunggu memory, SMT menguntungkan. Untuk beban kerja compute-bound padat seperti loop AVX, keduanya justru berebut sumber daya yang sama. Ini alasan SMT sering dimatikan di lingkungan HPC — keputusannya berdasarkan pengukuran, bukan preferensi.
* '''Hati-hati saat melakukan pinning.''' Karena satu core fisik menyumbang dua logical CPU, mem-''pin'' dua thread compute-heavy ke CPU 0 dan CPU 1 bisa saja berarti mengunci keduanya ke core fisik yang sama. Periksa topologi lebih dulu dengan <code>lscpu -e</code> atau <code>hwloc-ls</code>.
* '''Syarat pada poin kedua multiprocessing adalah inti Amdahl.''' Percepatan hanya datang dari bagian yang bisa diparalelkan. Bagian serial program menjadi batas atas yang tidak bisa dilewati berapa pun jumlah core yang ditambahkan.

{{Tip|Tiga perintah untuk melihat ketiga level sekaligus: <code>lscpu -e</code> untuk topologi thread-level, <code>perf stat -e instructions,cycles ./prog</code> untuk ILP, dan <code>objdump -d ./prog {{!}} grep -E 'vadd{{!}}vmul'</code> untuk memastikan instruksi SIMD benar-benar dihasilkan.}}

== Istilah kunci ==

; Concurrency
: Konsep umum sistem dengan banyak aktivitas simultan.
; Parallelism
: Penggunaan concurrency untuk membuat sistem berjalan lebih cepat.
; Uniprocessor system
: Sistem dengan satu processor yang bergantian antar tugas.
; Multiprocessor system
: Sistem dengan beberapa processor di bawah kendali satu kernel OS.
; Multi-core processor
: Beberapa CPU (core) yang diintegrasikan ke satu chip sirkuit terpadu.
; Hyperthreading
: Teknik yang memungkinkan satu CPU mengeksekusi beberapa alur kontrol dengan menduplikasi sebagian hardware seperti PC dan register file; disebut juga simultaneous multi-threading.
; Instruction-level parallelism
: Kemampuan processor mengeksekusi beberapa instruksi sekaligus.
; Pipelining
: Pembagian eksekusi instruksi jadi beberapa stage yang bisa beroperasi paralel.
; Superscalar
: Processor yang mempertahankan laju eksekusi lebih dari 1 instruksi per siklus.
; SIMD parallelism
: Mode ketika satu instruksi menyebabkan beberapa operasi dilakukan paralel.

== Lihat juga ==

* [[Process]]
* [[Threads]]
* [[Virtual Memory]]
* [[Files]]

Linux & Operating System

2026-09-05T02:49:11Z

SanzSkuy:

Main Page

2026-09-01T13:02:43Z

SanzSkuy:

'''Haidhi Angkawijana Tedja''' 
Software Engineer @ Telkom Indonesia

I write everything that I learn

[https://github.com/haidhiSkuy GitHub] • [https://www.linkedin.com/in/haidhi-angkawijana-tedja/ LinkedIn] • haidhiangkawijana@gmail.com

== Research Interests ==
* Heterogeneous Computing
* High-Performance Computing (HPC)
* GPU/Accelerator Architectures
* Edge Computing
* Hardware-Software Co-design for AI Systems

== Education ==
=== South Tangerang Institute of Technology (ITTS) ===
''2021 – 2025''
* B.Sc. in Computer Science
* Undergraduate Thesis: "Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization"
* Advised by [https://id.wikipedia.org/wiki/Onno_W._Purbo Onno W. Purbo]

=== Pondok Pesantren Riyadhussholihiin ===
''2016 - 2021''
* Language Class (Arabic)
* Organisasi Santri Riyadhussholihin & Baitul Qur'an
* Grade: Mumtaz (excellent)

== Work Experience ==
* Telkom Indonesia — AI & Backend Engineer ''(July 2024 – Present)''
* Meister Sinergi Indonesia (AERY) — ML/AI Engineer ''(October 2023 – Present)''
* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''
* Riyadhussholihiin Islamic Boarding School, Pandeglang — Tahfidz Teacher ''(July 2020 - July 2021)''

== Publication ==
* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608

== CV ==
* [https://drive.google.com/file/d/1y4H7s0E_N3XzCqi9o1iVPRj-KdLHOlEJ/view?usp=sharing CV_Haidhi_Angkawijana_Tedja.pdf]

== Categories ==
* [[Daftar Isi AI/ML|Artificial Intelligence, Machine Learning, & Data Science]]
* [[Daftar Isi Cybersecurity|Cybersecurity]]
* [[Linux & Operating System]]
* [[DevOps]]
* [[Web Assembly]]
* [[High-performance computing]]
* [[Programming, Software Engineering, etc]]
* [[Aerospace Engineering]]
* [[Ringkasan Buku]]
* [[Istilah Penting]]

 
<pre>
Imam Syafi'i رحمه الله:

الْعِلْمُ صَيْدٌ وَالْكِتَابَةُ قَيْدُهُ * قَيِّدْ صُيُوْدَكَ بِالْحِبَالِ الْوَاثِقَهْ
فَمِنَ الْحَمَاقَةِ أَنْ تَصِيْدَ غَزَالَةً وَتَتْرُكَهَا بَيْنَ الْخَلاَئِقِ طَالِقَهْ

Knowledge is a quarry, and the written word its chain.
Bind thy quarry fast with cords unyielding.
For folly it is to hunt the stag,
Only to loose it once more among the wilds.
</pre>

Main Page

2026-09-01T03:30:26Z

SanzSkuy:

'''Haidhi Angkawijana Tedja''' 
Software Engineer @ Telkom Indonesia

I write everything that I learn

[https://github.com/haidhiSkuy GitHub] • [https://www.linkedin.com/in/haidhi-angkawijana-tedja/ LinkedIn] • haidhiangkawijana@gmail.com

== Research Interests ==
* Heterogeneous Computing
* High-Performance Computing (HPC)
* GPU/Accelerator Architectures
* Edge Computing
* Hardware-Software Co-design for AI Systems

== Education ==
=== South Tangerang Institute of Technology (ITTS) ===
''2021 – 2025''
* B.Sc. in Computer Science
* Undergraduate Thesis: "Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization"
* Advised by [https://id.wikipedia.org/wiki/Onno_W._Purbo Onno W. Purbo]

=== Pondok Pesantren Riyadhussholihiin ===
''' 2016 - 2021 '''
* Language Class (Arabic)
* Organisasi Santri Riyadhussholihin & Baitul Qur'an
* Grade: Mumtaz (excellent)

== Work Experience ==
* Telkom Indonesia — AI & Backend Engineer ''(July 2024 – Present)''
* Meister Sinergi Indonesia (AERY) — ML/AI Engineer ''(October 2023 – Present)''
* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''
* Riyadhussholihiin Islamic Boarding School, Pandeglang — Tahfidz Teacher ''(July 2020 - July 2021)''

== Publication ==
* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608

== CV ==
* [https://drive.google.com/file/d/1y4H7s0E_N3XzCqi9o1iVPRj-KdLHOlEJ/view?usp=sharing CV_Haidhi_Angkawijana_Tedja.pdf]

== Categories ==
* [[Daftar Isi AI/ML|Artificial Intelligence, Machine Learning, & Data Science]]
* [[Daftar Isi Cybersecurity|Cybersecurity]]
* [[Linux & Operating System]]
* [[DevOps]]
* [[Web Assembly]]
* [[High-performance computing]]
* [[Programming, Software Engineering, etc]]
* [[Aerospace Engineering]]
* [[Ringkasan Buku]]
* [[Istilah Penting]]

 
<pre>
Imam Syafi'i رحمه الله:

الْعِلْمُ صَيْدٌ وَالْكِتَابَةُ قَيْدُهُ * قَيِّدْ صُيُوْدَكَ بِالْحِبَالِ الْوَاثِقَهْ
فَمِنَ الْحَمَاقَةِ أَنْ تَصِيْدَ غَزَالَةً وَتَتْرُكَهَا بَيْنَ الْخَلاَئِقِ طَالِقَهْ

Knowledge is a quarry, and the written word its chain.
Bind thy quarry fast with cords unyielding.
For folly it is to hunt the stag,
Only to loose it once more among the wilds.
</pre>

Main Page

2026-09-01T02:39:44Z

SanzSkuy:

'''Haidhi Angkawijana Tedja''' 
Software Engineer @ Telkom Indonesia

I write everything that I learnt

[https://github.com/haidhiSkuy GitHub] • [https://www.linkedin.com/in/haidhi-angkawijana-tedja/ LinkedIn] • haidhiangkawijana@gmail.com

== Research Interests ==
* Heterogeneous Computing
* High-Performance Computing (HPC)
* GPU/Accelerator Architectures
* Edge Computing
* Hardware-Software Co-design for AI Systems

== Education ==
=== South Tangerang Institute of Technology (ITTS) ===
''2021 – 2025''
* B.Sc. in Computer Science
* Undergraduate Thesis: "Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization"
* Advised by [https://id.wikipedia.org/wiki/Onno_W._Purbo Onno W. Purbo]

== Work Experience ==
* Telkom Indonesia — AI & Backend Engineer ''(July 2024 – Present)''
* Meister Sinergi Indonesia (AERY) — ML/AI Engineer ''(October 2023 – Present)''
* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''

== Publication ==
* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608

== CV ==
* [https://drive.google.com/file/d/1y4H7s0E_N3XzCqi9o1iVPRj-KdLHOlEJ/view?usp=sharing CV_Haidhi_Angkawijana_Tedja.pdf]

== Categories ==
* [[Daftar Isi AI/ML|Artificial Intelligence, Machine Learning, & Data Science]]
* [[Daftar Isi Cybersecurity|Cybersecurity]]
* [[Linux & Operating System]]
* [[DevOps]]
* [[Web Assembly]]
* [[High-performance computing]]
* [[Programming, Software Engineering, etc]]
* [[Aerospace Engineering]]
* [[Ringkasan Buku]]
* [[Istilah Penting]]

 
<pre>
Imam Syafi'i رحمه الله:

الْعِلْمُ صَيْدٌ وَالْكِتَابَةُ قَيْدُهُ * قَيِّدْ صُيُوْدَكَ بِالْحِبَالِ الْوَاثِقَهْ
فَمِنَ الْحَمَاقَةِ أَنْ تَصِيْدَ غَزَالَةً وَتَتْرُكَهَا بَيْنَ الْخَلاَئِقِ طَالِقَهْ

Knowledge is a quarry, and the written word its chain.
Bind thy quarry fast with cords unyielding.
For folly it is to hunt the stag,
Only to loose it once more among the wilds.
</pre>

Main Page

2026-09-01T02:33:03Z

SanzSkuy:

'''Haidhi Angkawijana Tedja''' 
Software Engineer @ Telkom Indonesia

[https://github.com/haidhiSkuy GitHub] • [https://www.linkedin.com/in/haidhi-angkawijana-tedja/ LinkedIn] • haidhiangkawijana@gmail.com

== Research Interests ==
* Heterogeneous Computing
* High-Performance Computing (HPC)
* GPU/Accelerator Architectures
* Edge Computing
* Hardware-Software Co-design for AI Systems

== Education ==
=== South Tangerang Institute of Technology (ITTS) ===
''2021 – 2025''
* B.Sc. in Computer Science, GPA 3.96/4.00
* Undergraduate Thesis: "Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization"
* Advised by [[Onno W. Purbo|Dr. Onno W. Purbo]]

== Work Experience ==
* Telkom Indonesia — AI & Backend Engineer ''(July 2024 – Present)''
* Meister Sinergi Indonesia (AERY) — ML/AI Engineer ''(October 2023 – Present)''
* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''

== Publication ==
* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608

== Technical Skills ==
* '''Languages & Frameworks:''' Python, Rust, C++, FastAPI, Actix Web
* '''ML/DL:''' PyTorch, scikit-learn, Pandas, NumPy, OpenCV
* '''HPC & Systems:''' MPI, OpenCL, CUDA (basic), Linux, OpenShift, CI/CD

== CV ==
* [[File:CV_Haidhi_Angkawijana_Tedja.pdf|CV_Haidhi_Angkawijana_Tedja.pdf]]

== Categories ==
* [[Daftar Isi AI/ML|Artificial Intelligence, Machine Learning, & Data Science]]
* [[Daftar Isi Cybersecurity|Cybersecurity]]
* [[Linux & Operating System]]
* [[DevOps]]
* [[Web Assembly]]
* [[High-performance computing]]
* [[Programming, Software Engineering, etc]]
* [[Aerospace Engineering]]
* [[Ringkasan Buku]]
* [[Istilah Penting]]

 
<pre>
Imam Syafi'i رحمه الله:

الْعِلْمُ صَيْدٌ وَالْكِتَابَةُ قَيْدُهُ * قَيِّدْ صُيُوْدَكَ بِالْحِبَالِ الْوَاثِقَهْ
فَمِنَ الْحَمَاقَةِ أَنْ تَصِيْدَ غَزَالَةً وَتَتْرُكَهَا بَيْنَ الْخَلاَئِقِ طَالِقَهْ

Knowledge is a quarry, and the written word its chain.
Bind thy quarry fast with cords unyielding.
For folly it is to hunt the stag,
Only to loose it once more among the wilds.
</pre>

Files

2026-08-24T06:35:00Z

SanzSkuy:

== Definisi ==

'''File adalah urutan byte. Tidak lebih, tidak kurang.'''

Kalimat itu ditulis persis begitu di buku, dan penekanannya bukan sekadar gaya bahasa. Frasa ''"tidak lebih, tidak kurang"'' menegaskan bahwa operating system '''sengaja menolak tahu''' apa isi sebuah file:

* tidak ada tipe data
* tidak ada struktur internal
* tidak ada konsep record atau baris

Cuma deretan byte, dan penafsirannya sepenuhnya urusan aplikasi.

{{Catatan|title=Kenapa justru itu kekuatannya|Karena model file tidak mengasumsikan apa pun tentang isinya, semua jenis device bisa dimuat ke dalam model yang sama. Andai OS memaksakan struktur tertentu, keyboard dan socket jaringan tidak akan pernah muat ke dalamnya.}}

== Semua device adalah file ==

'''Setiap I/O device dimodelkan sebagai file''' — termasuk:

* disk
* keyboard
* display
* bahkan '''jaringan'''

Konsekuensinya menyeluruh: '''seluruh input dan output di sistem dilakukan dengan membaca dan menulis file''', menggunakan sekumpulan kecil system call yang dikenal sebagai '''Unix I/O'''.

<pre>
Aplikasi
|
open / read / write / close <- Unix I/O
|
+---------+--------+--------+----------+
| | | | |
Disk Keyboard Display Network ...
</pre>

Perhatikan bentuk corongnya: banyak device yang bentuk fisiknya sangat berbeda, tapi semuanya masuk lewat antarmuka yang sama dan jumlah system call-nya sedikit.

== Kenapa ini powerful ==

Gagasan file yang '''sederhana dan elegan''' ini ternyata sangat kuat, karena memberi aplikasi '''tampilan yang seragam atas semua I/O device''' yang mungkin ada di sistem.

Dua konsekuensi yang disebut buku:

# '''Programmer tidak perlu tahu teknologi device-nya.''' Yang memanipulasi isi file di disk, dalam istilah buku, ''blissfully unaware'' soal teknologi disk yang dipakai. Mau NVMe, SATA, atau apa pun, kodenya sama.
# '''Program yang sama jalan di sistem berbeda.''' Program itu tetap berjalan di sistem yang memakai teknologi disk yang berbeda, tanpa perlu diubah.

Ini contoh konkret dari tujuan kedua operating system yang dibahas di [[Operating System Mengelola Hardware]]: menyediakan mekanisme yang sederhana dan seragam untuk hardware low-level yang bentuknya beda-beda.

Unix I/O dibahas di '''Bab 10'''.

== Catatan untuk kerja systems ==

* '''File descriptor adalah wujud praktis abstraksi ini.''' Setelah <code>open</code>, sebuah file diwakili integer kecil. Tiga di antaranya sudah disiapkan sejak process lahir: <code>0</code> stdin, <code>1</code> stdout, <code>2</code> stderr. Karena semuanya cuma integer yang menunjuk ke urutan byte, ''pipe'' dan ''redirection'' di shell jadi mungkin tanpa program perlu tahu apa-apa.
* '''Device benar-benar muncul sebagai file di filesystem.''' Lihat isi <code>/dev</code>. Ada <code>/dev/null</code>, <code>/dev/zero</code>, <code>/dev/random</code>, sampai disk mentah seperti <code>/dev/nvme0n1</code>. Bahkan state kernel dipaparkan sebagai file lewat <code>/proc</code> dan <code>/sys</code> — <code>/proc/[pid]/maps</code> yang dipakai di catatan [[Virtual Memory]] adalah contohnya.
* '''Socket adalah pengecualian sebagian.''' Setelah terhubung, socket bisa dibaca dan ditulis seperti file biasa. Tapi untuk membuatnya tetap butuh system call khusus: <code>socket</code>, <code>bind</code>, <code>listen</code>, <code>accept</code>, <code>connect</code>. Jadi model file tidak menutupi seluruh siklus hidupnya.
* '''<code>ioctl</code> adalah pintu darurat abstraksi ini.''' Begitu ada operasi device yang tidak bisa dinyatakan sebagai baca atau tulis byte — mengatur baud rate serial, mengeluarkan tray CD, mengubah mode terminal — semuanya ditumpuk ke <code>ioctl</code>. Keberadaan <code>ioctl</code> adalah pengakuan jujur bahwa abstraksi file tidak sempurna.
* '''Plan 9 mendorong ide ini sampai ujung.''' Sistem operasi penerus Unix dari Bell Labs itu membuat hampir segalanya benar-benar file, termasuk antarmuka jaringan dan window grafis. Sering disebut sebagai versi "Unix yang konsisten sepenuhnya", dan berguna sebagai pembanding untuk melihat di mana Unix sendiri berkompromi.
* '''Keseragaman punya harga performa.''' Karena semua I/O lewat jalur yang sama, tiap operasi berarti satu system call dan penyalinan data antara kernel dan user space. Di sistem berthroughput tinggi, biaya itu dikurangi lewat <code>mmap</code>, <code>sendfile</code>, <code>O_DIRECT</code>, atau <code>io_uring</code> yang membatch banyak operasi jadi satu perjalanan ke kernel.

{{Tip|Cara cepat merasakan abstraksi ini: jalankan <code>ls -l /proc/self/fd</code> untuk melihat file descriptor milik process yang sedang berjalan, atau <code>strace -e trace=openat,read,write ./program</code> untuk melihat setiap operasi Unix I/O yang benar-benar terjadi.}}

== Ringkasan tiga abstraksi ==

Dengan bagian ini, tiga abstraksi fundamental dari Figure 1.11 sudah lengkap:

{| class="wikitable"
! Abstraksi !! Menutupi !! Dibahas di
|-
| [[Process|Process]] || Processor, main memory, I/O devices || Bab 8
|-
| [[Virtual Memory|Virtual memory]] || Main memory dan disk I/O devices || Bab 9
|-
| File || I/O devices || Bab 10
|}

== Istilah kunci ==

; File
: Urutan byte, tidak lebih dan tidak kurang; model OS untuk semua I/O device.
; Unix I/O
: Sekumpulan kecil system call untuk melakukan seluruh input dan output di sistem.
; File descriptor
: Integer kecil yang mewakili file terbuka di dalam sebuah process.
; ioctl
: System call serbaguna untuk operasi device yang tidak bisa dinyatakan sebagai baca atau tulis byte.

== Lihat juga ==

* [[OS Manages Hardware]]
* [[Process]]
* [[Virtual Memory]]
* [[System Call]]

Files

2026-08-24T06:32:56Z

SanzSkuy:

== Definisi ==

'''File adalah urutan byte. Tidak lebih, tidak kurang.'''

Kalimat itu ditulis persis begitu di buku, dan penekanannya bukan sekadar gaya bahasa. Frasa ''"tidak lebih, tidak kurang"'' menegaskan bahwa operating system '''sengaja menolak tahu''' apa isi sebuah file:

* tidak ada tipe data
* tidak ada struktur internal
* tidak ada konsep record atau baris

Cuma deretan byte, dan penafsirannya sepenuhnya urusan aplikasi.

{{Catatan|title=Kenapa justru itu kekuatannya|Karena model file tidak mengasumsikan apa pun tentang isinya, semua jenis device bisa dimuat ke dalam model yang sama. Andai OS memaksakan struktur tertentu, keyboard dan socket jaringan tidak akan pernah muat ke dalamnya.}}

== Semua device adalah file ==

'''Setiap I/O device dimodelkan sebagai file''' — termasuk:

* disk
* keyboard
* display
* bahkan '''jaringan'''

Konsekuensinya menyeluruh: '''seluruh input dan output di sistem dilakukan dengan membaca dan menulis file''', menggunakan sekumpulan kecil system call yang dikenal sebagai '''Unix I/O'''.

<pre>
Aplikasi
|
open / read / write / close <- Unix I/O
|
+---------+--------+--------+----------+
| | | | |
Disk Keyboard Display Network ...
</pre>

Perhatikan bentuk corongnya: banyak device yang bentuk fisiknya sangat berbeda, tapi semuanya masuk lewat antarmuka yang sama dan jumlah system call-nya sedikit.

== Kenapa ini powerful ==

Gagasan file yang '''sederhana dan elegan''' ini ternyata sangat kuat, karena memberi aplikasi '''tampilan yang seragam atas semua I/O device''' yang mungkin ada di sistem.

Dua konsekuensi yang disebut buku:

# '''Programmer tidak perlu tahu teknologi device-nya.''' Yang memanipulasi isi file di disk, dalam istilah buku, ''blissfully unaware'' soal teknologi disk yang dipakai. Mau NVMe, SATA, atau apa pun, kodenya sama.
# '''Program yang sama jalan di sistem berbeda.''' Program itu tetap berjalan di sistem yang memakai teknologi disk yang berbeda, tanpa perlu diubah.

Ini contoh konkret dari tujuan kedua operating system yang dibahas di [[Operating System Mengelola Hardware]]: menyediakan mekanisme yang sederhana dan seragam untuk hardware low-level yang bentuknya beda-beda.

Unix I/O dibahas di '''Bab 10'''.

== Catatan untuk kerja systems ==

* '''File descriptor adalah wujud praktis abstraksi ini.''' Setelah <code>open</code>, sebuah file diwakili integer kecil. Tiga di antaranya sudah disiapkan sejak process lahir: <code>0</code> stdin, <code>1</code> stdout, <code>2</code> stderr. Karena semuanya cuma integer yang menunjuk ke urutan byte, ''pipe'' dan ''redirection'' di shell jadi mungkin tanpa program perlu tahu apa-apa.
* '''Device benar-benar muncul sebagai file di filesystem.''' Lihat isi <code>/dev</code>. Ada <code>/dev/null</code>, <code>/dev/zero</code>, <code>/dev/random</code>, sampai disk mentah seperti <code>/dev/nvme0n1</code>. Bahkan state kernel dipaparkan sebagai file lewat <code>/proc</code> dan <code>/sys</code> — <code>/proc/[pid]/maps</code> yang dipakai di catatan [[Virtual Memory]] adalah contohnya.
* '''Socket adalah pengecualian sebagian.''' Setelah terhubung, socket bisa dibaca dan ditulis seperti file biasa. Tapi untuk membuatnya tetap butuh system call khusus: <code>socket</code>, <code>bind</code>, <code>listen</code>, <code>accept</code>, <code>connect</code>. Jadi model file tidak menutupi seluruh siklus hidupnya.
* '''<code>ioctl</code> adalah pintu darurat abstraksi ini.''' Begitu ada operasi device yang tidak bisa dinyatakan sebagai baca atau tulis byte — mengatur baud rate serial, mengeluarkan tray CD, mengubah mode terminal — semuanya ditumpuk ke <code>ioctl</code>. Keberadaan <code>ioctl</code> adalah pengakuan jujur bahwa abstraksi file tidak sempurna.
* '''Plan 9 mendorong ide ini sampai ujung.''' Sistem operasi penerus Unix dari Bell Labs itu membuat hampir segalanya benar-benar file, termasuk antarmuka jaringan dan window grafis. Sering disebut sebagai versi "Unix yang konsisten sepenuhnya", dan berguna sebagai pembanding untuk melihat di mana Unix sendiri berkompromi.
* '''Keseragaman punya harga performa.''' Karena semua I/O lewat jalur yang sama, tiap operasi berarti satu system call dan penyalinan data antara kernel dan user space. Di sistem berthroughput tinggi, biaya itu dikurangi lewat <code>mmap</code>, <code>sendfile</code>, <code>O_DIRECT</code>, atau <code>io_uring</code> yang membatch banyak operasi jadi satu perjalanan ke kernel.

{{Tip|Cara cepat merasakan abstraksi ini: jalankan <code>ls -l /proc/self/fd</code> untuk melihat file descriptor milik process yang sedang berjalan, atau <code>strace -e trace=openat,read,write ./program</code> untuk melihat setiap operasi Unix I/O yang benar-benar terjadi.}}

== Ringkasan tiga abstraksi ==

Dengan bagian ini, tiga abstraksi fundamental dari Figure 1.11 sudah lengkap:

{| class="wikitable"
! Abstraksi !! Menutupi !! Dibahas di
|-
| [[Processes|Process]] || Processor, main memory, I/O devices || Bab 8
|-
| [[Virtual Memory|Virtual memory]] || Main memory dan disk I/O devices || Bab 9
|-
| File || I/O devices || Bab 10
|}

== Istilah kunci ==

; File
: Urutan byte, tidak lebih dan tidak kurang; model OS untuk semua I/O device.
; Unix I/O
: Sekumpulan kecil system call untuk melakukan seluruh input dan output di sistem.
; File descriptor
: Integer kecil yang mewakili file terbuka di dalam sebuah process.
; ioctl
: System call serbaguna untuk operasi device yang tidak bisa dinyatakan sebagai baca atau tulis byte.

== Lihat juga ==

* [[OS Manages Hardware]]
* [[Process]]
* [[Virtual Memory]]
* [[System Call]]

Files

2026-08-24T06:32:40Z

SanzSkuy: Created page with "== Definisi == '''File adalah urutan byte. Tidak lebih, tidak kurang.''' Kalimat itu ditulis persis begitu di buku, dan penekanannya bukan sekadar gaya bahasa. Frasa ''"tidak lebih, tidak kurang"'' menegaskan bahwa operating system '''sengaja menolak tahu''' apa isi sebuah file: * tidak ada tipe data * tidak ada struktur internal * tidak ada konsep record atau baris Cuma deretan byte, dan penafsirannya sepenuhnya urusan aplikasi. {{Catatan|title=Kenapa justru itu ke..."

== Definisi ==

'''File adalah urutan byte. Tidak lebih, tidak kurang.'''

Kalimat itu ditulis persis begitu di buku, dan penekanannya bukan sekadar gaya bahasa. Frasa ''"tidak lebih, tidak kurang"'' menegaskan bahwa operating system '''sengaja menolak tahu''' apa isi sebuah file:

* tidak ada tipe data
* tidak ada struktur internal
* tidak ada konsep record atau baris

Cuma deretan byte, dan penafsirannya sepenuhnya urusan aplikasi.

{{Catatan|title=Kenapa justru itu kekuatannya|Karena model file tidak mengasumsikan apa pun tentang isinya, semua jenis device bisa dimuat ke dalam model yang sama. Andai OS memaksakan struktur tertentu, keyboard dan socket jaringan tidak akan pernah muat ke dalamnya.}}

== Semua device adalah file ==

'''Setiap I/O device dimodelkan sebagai file''' — termasuk:

* disk
* keyboard
* display
* bahkan '''jaringan'''

Konsekuensinya menyeluruh: '''seluruh input dan output di sistem dilakukan dengan membaca dan menulis file''', menggunakan sekumpulan kecil system call yang dikenal sebagai '''Unix I/O'''.

<pre>
Aplikasi
|
open / read / write / close <- Unix I/O
|
+---------+--------+--------+----------+
| | | | |
Disk Keyboard Display Network ...
</pre>

Perhatikan bentuk corongnya: banyak device yang bentuk fisiknya sangat berbeda, tapi semuanya masuk lewat antarmuka yang sama dan jumlah system call-nya sedikit.

== Kenapa ini powerful ==

Gagasan file yang '''sederhana dan elegan''' ini ternyata sangat kuat, karena memberi aplikasi '''tampilan yang seragam atas semua I/O device''' yang mungkin ada di sistem.

Dua konsekuensi yang disebut buku:

# '''Programmer tidak perlu tahu teknologi device-nya.''' Yang memanipulasi isi file di disk, dalam istilah buku, ''blissfully unaware'' soal teknologi disk yang dipakai. Mau NVMe, SATA, atau apa pun, kodenya sama.
# '''Program yang sama jalan di sistem berbeda.''' Program itu tetap berjalan di sistem yang memakai teknologi disk yang berbeda, tanpa perlu diubah.

Ini contoh konkret dari tujuan kedua operating system yang dibahas di [[Operating System Mengelola Hardware]]: menyediakan mekanisme yang sederhana dan seragam untuk hardware low-level yang bentuknya beda-beda.

Unix I/O dibahas di '''Bab 10'''.

== Catatan untuk kerja systems ==

* '''File descriptor adalah wujud praktis abstraksi ini.''' Setelah <code>open</code>, sebuah file diwakili integer kecil. Tiga di antaranya sudah disiapkan sejak process lahir: <code>0</code> stdin, <code>1</code> stdout, <code>2</code> stderr. Karena semuanya cuma integer yang menunjuk ke urutan byte, ''pipe'' dan ''redirection'' di shell jadi mungkin tanpa program perlu tahu apa-apa.
* '''Device benar-benar muncul sebagai file di filesystem.''' Lihat isi <code>/dev</code>. Ada <code>/dev/null</code>, <code>/dev/zero</code>, <code>/dev/random</code>, sampai disk mentah seperti <code>/dev/nvme0n1</code>. Bahkan state kernel dipaparkan sebagai file lewat <code>/proc</code> dan <code>/sys</code> — <code>/proc/[pid]/maps</code> yang dipakai di catatan [[Virtual Memory]] adalah contohnya.
* '''Socket adalah pengecualian sebagian.''' Setelah terhubung, socket bisa dibaca dan ditulis seperti file biasa. Tapi untuk membuatnya tetap butuh system call khusus: <code>socket</code>, <code>bind</code>, <code>listen</code>, <code>accept</code>, <code>connect</code>. Jadi model file tidak menutupi seluruh siklus hidupnya.
* '''<code>ioctl</code> adalah pintu darurat abstraksi ini.''' Begitu ada operasi device yang tidak bisa dinyatakan sebagai baca atau tulis byte — mengatur baud rate serial, mengeluarkan tray CD, mengubah mode terminal — semuanya ditumpuk ke <code>ioctl</code>. Keberadaan <code>ioctl</code> adalah pengakuan jujur bahwa abstraksi file tidak sempurna.
* '''Plan 9 mendorong ide ini sampai ujung.''' Sistem operasi penerus Unix dari Bell Labs itu membuat hampir segalanya benar-benar file, termasuk antarmuka jaringan dan window grafis. Sering disebut sebagai versi "Unix yang konsisten sepenuhnya", dan berguna sebagai pembanding untuk melihat di mana Unix sendiri berkompromi.
* '''Keseragaman punya harga performa.''' Karena semua I/O lewat jalur yang sama, tiap operasi berarti satu system call dan penyalinan data antara kernel dan user space. Di sistem berthroughput tinggi, biaya itu dikurangi lewat <code>mmap</code>, <code>sendfile</code>, <code>O_DIRECT</code>, atau <code>io_uring</code> yang membatch banyak operasi jadi satu perjalanan ke kernel.

{{Tip|Cara cepat merasakan abstraksi ini: jalankan <code>ls -l /proc/self/fd</code> untuk melihat file descriptor milik process yang sedang berjalan, atau <code>strace -e trace=openat,read,write ./program</code> untuk melihat setiap operasi Unix I/O yang benar-benar terjadi.}}

== Ringkasan tiga abstraksi ==

Dengan bagian ini, tiga abstraksi fundamental dari Figure 1.11 sudah lengkap:

{| class="wikitable"
! Abstraksi !! Menutupi !! Dibahas di
|-
| [[Processes|Process]] || Processor, main memory, I/O devices || Bab 8
|-
| [[Virtual Memory|Virtual memory]] || Main memory dan disk I/O devices || Bab 9
|-
| File || I/O devices || Bab 10
|}

== Istilah kunci ==

; File
: Urutan byte, tidak lebih dan tidak kurang; model OS untuk semua I/O device.
; Unix I/O
: Sekumpulan kecil system call untuk melakukan seluruh input dan output di sistem.
; File descriptor
: Integer kecil yang mewakili file terbuka di dalam sebuah process.
; ioctl
: System call serbaguna untuk operasi device yang tidak bisa dinyatakan sebagai baca atau tulis byte.

== Lihat juga ==

* [[OS Manages Hardware]]
* [[Processes]]
* [[Virtual Memory]]
* [[System Call]]

OS Manages Hardware

2026-08-24T04:38:35Z

SanzSkuy:

Catatan dari '''CS:APP''' (''Computer Systems: A Programmer's Perspective'') §1.7 — tentang bagaimana operating system menjadi perantara tunggal antara aplikasi dan hardware.

__TOC__

== Kenapa bab ini penting ==

Balik ke contoh <code>hello</code>. Waktu shell nge-load dan menjalankan program <code>hello</code>, terus <code>hello</code> nge-print pesannya ke layar — '''nggak ada satu pun dari dua program itu yang nyentuh keyboard, display, disk, atau main memory secara langsung'''. Semuanya numpang layanan yang disediakan operating system.

Ini bukan detail sepele. Ini fondasi kenapa kita bisa nulis <code>printf("hello\n")</code> tanpa perlu tahu merek monitor atau protokol bus yang dipakai.

== Layered view ==

Model mentalnya: OS itu '''lapisan software yang disisipkan di antara aplikasi dan hardware'''.

<pre>
+-----------------------------------------+
| Application programs | <- Software
+-----------------------------------------+
| Operating system | <- Software
+-----------+--------------+--------------+
| Processor | Main memory | I/O devices | <- Hardware
+-----------+--------------+--------------+
</pre>

Aturannya keras: '''semua usaha aplikasi buat memanipulasi hardware harus lewat OS'''. Nggak ada jalan tikus. Kalau ada program yang mau nulis ke disk, dia harus minta ke OS.

Konsekuensi praktisnya: batas antara aplikasi dan OS itu adalah '''system call interface'''. Setiap kali kode kita nyebrang garis itu, ada biaya (''mode switch''), dan itu jadi salah satu sumber overhead yang paling sering muncul di profiling.

== Dua tujuan utama OS ==

=== Proteksi — melindungi hardware dari penyalahgunaan ===

Aplikasi yang ''runaway'' (bug, infinite loop, pointer liar) nggak boleh:

* nimpa memory milik proses lain
* monopoli CPU selamanya
* ngerusak state device

Mekanismenya nanti: privilege level (user mode vs kernel mode), MMU + page table buat isolasi memory, timer interrupt buat preemption.

=== Abstraksi — menyediakan mekanisme yang sederhana dan seragam ===

Hardware level rendah itu bentuknya '''beda-beda dan sering liar banget'''. Register controller SSD beda total sama register UART, beda lagi sama NIC. Kalau tiap aplikasi harus tahu detail tiap device, nulis program jadi mimpi buruk dan nggak portable.

OS nyediain satu antarmuka seragam supaya aplikasi cukup belajar satu cara.

== Tiga abstraksi fundamental ==

OS mencapai '''dua''' tujuan di atas lewat '''tiga''' abstraksi yang saling bertumpuk:

<pre>
+------------------------------------ Processes ----------+
| +-------------------- Virtual memory ------+|
| | +------ Files ----------+||
| +-----------+-+---------------+--+--------------------+||
| | Processor | Main memory | I/O devices |||
| +-------------+------------------+--------------------+||
+---------------------------------------------------------+
</pre>

Perhatiin '''cakupan''' tiap abstraksi — ini bagian yang sering ketuker:

{| class="wikitable"
! Abstraksi !! Hardware yang diabstraksikan
|-
| '''Files''' || I/O devices
|-
| '''Virtual memory''' || Main memory '''+''' disk I/O devices
|-
| '''Processes''' || Processor '''+''' main memory '''+''' I/O devices
|}

=== Files — abstraksi untuk I/O devices ===

Semua device dibungkus jadi "urutan byte". Disk, keyboard, terminal, socket jaringan — semuanya bisa dibuka, dibaca, ditulis, ditutup lewat API yang sama. Ini filosofi ''"everything is a file"'' yang khas Unix.

Efeknya: program yang nulis ke file bisa di-''pipe'' ke program lain tanpa modifikasi apa pun.

=== Virtual memory — abstraksi untuk main memory + disk ===

Tiap proses seolah-olah punya '''memory sendiri yang utuh dan kontinu''', mulai dari alamat 0 sampai batas atas ruang alamat. Padahal fisiknya memory itu dibagi-bagi dan sebagian bisa lagi "nginep" di disk.

Kenapa disk ikut masuk? Karena isi memory bisa di-''page out'' ke disk saat RAM sesak. Jadi virtual memory sebenarnya adalah abstraksi gabungan dari dua tingkat hierarki penyimpanan sekaligus.

Ini juga yang bikin proteksi jadi mungkin: kalau dua proses pakai alamat <code>0x400000</code>, itu merujuk ke halaman fisik yang beda.

=== Processes — abstraksi untuk seluruh mesin ===

Proses adalah ilusi bahwa '''program kita satu-satunya yang jalan di mesin ini''', dengan CPU-nya sendiri, memory-nya sendiri, dan device-nya sendiri.

Padahal aslinya puluhan sampai ratusan proses gantian pakai CPU yang jumlahnya jauh lebih sedikit. OS ngelakuin ''context switch'' — nyimpen state satu proses, restore state proses lain — cukup cepat sampai ilusinya nggak ketahuan.

Jadi processes itu abstraksi paling "atas": dia membungkus processor, main memory, '''dan''' I/O devices sekaligus.

== Cara ngingetnya ==

Tiga abstraksi itu tersusun kayak boneka matryoshka, makin ke atas makin banyak hardware yang dibungkus:

# '''Files''' → paling sempit, cuma I/O
# '''Virtual memory''' → nambah main memory ke dalamnya
# '''Processes''' → nambah processor, jadi lengkap

Dan dua tujuan (proteksi + antarmuka seragam) itu '''dicapai lewat''' tiga abstraksi ini, bukan hal yang terpisah.

== Catatan untuk kerja systems ==

Beberapa hal yang nyambung ke topik performance:

* '''System call itu nggak gratis.''' Karena semua akses hardware wajib lewat OS, jalur kritis yang sering nge-hit syscall bakal kena overhead ''mode switch''. Ini alasan kenapa ada teknik kayak batching I/O, <code>io_uring</code>, atau kernel bypass (DPDK, RDMA) di sistem yang butuh throughput tinggi.
* '''Virtual memory bukan cuma soal kapasitas.''' Page fault, TLB miss, dan NUMA placement semuanya lahir dari abstraksi ini. Program yang secara aritmetika identik bisa beda performanya berkali-kali lipat cuma gara-gara pola akses memory-nya beda.
* '''Context switch punya harga.''' Selain nyimpen register, cache dan TLB ikut "dingin" setelah switch. Ini salah satu alasan kenapa di HPC orang sering nge-''pin'' thread ke core tertentu.

== Istilah kunci ==

; Operating system
: Lapisan software antara aplikasi dan hardware.
; Abstraction
: Antarmuka sederhana yang menyembunyikan kompleksitas di bawahnya.
; Process
: Abstraksi untuk processor, main memory, dan I/O devices.
; Virtual memory
: Abstraksi untuk main memory dan disk I/O devices.
; File
: Abstraksi untuk I/O devices, dilihat sebagai urutan byte.
; Context switch
: Proses menyimpan dan memulihkan state saat CPU berpindah proses.

== Lihat juga ==

* [[Process]]
* [[Threads]]
* [[Virtual Memory]]
* [[Files]]
* [[System Call]]
* [[Context Switch]]
* [[CS:APP]]

[[Category:Computer Systems]]
[[Category:Operating System]]
[[Category:CS:APP]]

Virtual Memory

2026-08-24T04:38:24Z

SanzSkuy:

== Ilusi yang dijual ==

'''Virtual memory''' adalah abstraksi yang memberi tiap process ilusi bahwa dia '''punya akses eksklusif ke main memory'''.

Tiap process melihat memory dengan '''tampilan yang seragam''', dan tampilan itu disebut '''virtual address space'''. Seragam artinya: process apa pun, sekecil atau sebesar apa pun, melihat peta memory dengan struktur yang sama persis.

{{Catatan|Struktur pada Figure 1.13 adalah tata letak untuk process Linux. Sistem Unix lain memakai layout yang mirip.}}

== Tata letak ruang alamat ==

Pembagian besarnya cuma dua:

* '''Region paling atas''' — disediakan untuk code dan data operating system, dan ini '''sama untuk semua process'''.
* '''Region bawah''' — menampung code dan data yang didefinisikan oleh process milik user.

{{Warning|title=Arah alamat|Pada Figure 1.13, '''alamat bertambah dari bawah ke atas'''. Angka 0 ada di dasar gambar. Jadi "stack di atas" berarti alamatnya tinggi, dan "heap di bawah" berarti alamatnya rendah. Salah baca arah ini bikin seluruh diagram jadi terbalik maknanya.}}

<pre>
alamat tinggi
+---------------------------------+
| Kernel virtual memory | <- tidak terlihat oleh user code
+---------------------------------+
| User stack |
| (dibuat saat run time) |
| | |
| v tumbuh turun |
+---------------------------------+
| (ruang kosong) |
+---------------------------------+
| Memory-mapped region |
| untuk shared libraries | <- di sini fungsi printf berada
+---------------------------------+
| (ruang kosong) |
| ^ tumbuh naik |
+---------------------------------+
| Run-time heap |
| (dibuat oleh malloc) |
+---------------------------------+
| Read/write data | \
+---------------------------------+ > dimuat dari file
| Read-only code and data | / executable hello
+---------------------------------+ <- program start
| |
+---------------------------------+ 0
alamat rendah
</pre>

== Area-area penting ==

Dibahas dari alamat terendah naik ke atas.

=== Program code and data ===

Code dimulai pada '''alamat tetap yang sama untuk semua process''', diikuti lokasi data yang berkorespondensi dengan variabel global C.

Yang khas dari area ini: isinya '''diinisialisasi langsung dari isi file executable object''' — dalam contoh kita, file <code>hello</code>. Jadi area ini bukan dibangun saat runtime, tapi disalin dari file di disk.

Ukurannya '''tetap begitu process mulai jalan'''.

Dibahas lebih lanjut di '''Bab 7''' (linking dan loading).

=== Heap ===

Langsung menyusul area code dan data. Berbeda dari code dan data yang ukurannya tetap, heap '''memuai dan menyusut secara dinamis saat run time''' sebagai akibat pemanggilan rutin pustaka standar C seperti <code>malloc</code> dan <code>free</code>.

Dibahas detail di '''Bab 9'''.

=== Shared libraries ===

Berada di '''sekitar tengah''' ruang alamat. Menampung code dan data untuk shared library seperti pustaka standar C dan pustaka matematika.

Inilah tempat fungsi <code>printf</code> yang dipanggil <code>hello</code> sebenarnya berada — bukan di dalam executable-nya sendiri.

CS:APP sendiri menyebut konsep shared library ini '''powerful tapi agak sulit'''. Mekanismenya dibahas di '''Bab 7''' (dynamic linking).

=== User stack ===

Berada di '''puncak ruang alamat user'''. Dipakai '''compiler untuk mengimplementasikan pemanggilan fungsi'''.

Seperti heap, stack juga memuai dan menyusut secara dinamis selama program berjalan:

* tiap kali kita '''memanggil''' fungsi → stack '''tumbuh'''
* tiap kali kita '''return''' dari fungsi → stack '''menyusut'''

Cara compiler memakai stack dibahas di '''Bab 3'''.

=== Kernel virtual memory ===

Region paling atas, disediakan untuk kernel. Aturannya tegas — program aplikasi '''tidak diizinkan''':

* membaca isi area ini
* menulis ke area ini
* memanggil langsung fungsi yang didefinisikan di kode kernel

Sebagai gantinya, aplikasi harus '''meminta kernel''' untuk melakukan operasi tersebut, yaitu lewat system call. Ini menyambung langsung ke pembahasan di [[Processes]].

== Cara kerjanya ==

Supaya virtual memory bisa bekerja, dibutuhkan '''interaksi yang rumit antara hardware dan software operating system''', termasuk '''penerjemahan alamat oleh hardware untuk setiap alamat yang dihasilkan processor'''.

Perhatikan kata '''setiap'''. Ini bukan operasi sesekali — tiap kali instruksi menyentuh memory, ada terjemahan alamat virtual ke alamat fisik yang terjadi di hardware.

Ide dasarnya:

# Simpan isi virtual memory sebuah process '''di disk'''.
# Gunakan '''main memory sebagai cache untuk disk''' itu.

{{Catatan|title=Model mental yang terbalik|Poin kedua ini biasanya yang paling mengejutkan. Kita terbiasa berpikir RAM sebagai tempat penyimpanan utama dan disk sebagai cadangan. Virtual memory membalik posisinya: disk adalah tempat data sebenarnya berada, dan RAM cuma lapisan cache yang cepat di depannya. Sudut pandang ini yang bikin konsep page fault jadi masuk akal.}}

Penjelasan lengkapnya, dan kenapa ini begitu penting untuk sistem modern, ada di '''Bab 9'''.

== Catatan untuk kerja systems ==

* '''"Code dimulai pada alamat tetap yang sama" sudah tidak sepenuhnya berlaku.''' Pernyataan itu benar untuk binary non-PIE. Linux modern mengompilasi binary sebagai PIE dan mengaktifkan '''ASLR''', sehingga alamat basis code, heap, stack, dan shared library diacak tiap kali process dijalankan — sebagai pertahanan terhadap eksploitasi. Cek dengan menjalankan <code>cat /proc/self/maps</code> dua kali dan bandingkan hasilnya. Untuk debugging bisa dimatikan sementara dengan <code>setarch -R</code>.
* '''Peta ini bisa dilihat langsung.''' <code>/proc/[pid]/maps</code> menampilkan seluruh region beserta permission dan file pendukungnya. Ini cara tercepat memverifikasi bahwa Figure 1.13 memang benar-benar ada, bukan sekadar model.
* '''Heap besar tidak selalu lewat heap.''' <code>malloc</code> di glibc memakai <code>brk</code> untuk alokasi kecil, tapi beralih ke <code>mmap</code> untuk alokasi di atas ambang tertentu (<code>M_MMAP_THRESHOLD</code>, default sekitar 128 KB). Jadi alokasi besar sebenarnya mendarat di region memory-mapped, bukan di run-time heap.
* '''Stack punya batas keras.''' Stack memang tumbuh otomatis, tapi hanya sampai <code>RLIMIT_STACK</code> (umumnya 8 MB). Di bawahnya ada ''guard page'' — menyentuhnya memicu SIGSEGV. Inilah yang terjadi pada rekursi tanpa henti.
* '''Alokasi tidak sama dengan memory fisik.''' Linux melakukan ''overcommit'': <code>malloc</code> yang sukses cuma berarti ruang alamat sudah dicadangkan, halaman fisiknya baru diberikan saat benar-benar disentuh (''demand paging''). Konsekuensinya, program bisa mati kena OOM killer di titik penulisan, bukan di titik alokasi.
* '''Terjemahan setiap alamat itu mahal, makanya ada TLB.''' Karena tiap akses memory butuh penerjemahan, hasil terjemahan di-cache di ''Translation Lookaside Buffer''. TLB miss adalah biaya nyata di workload dengan pola akses acak, dan itulah alasan ''huge pages'' bisa memberi percepatan besar di aplikasi seperti database dan HPC.

{{Tip|Kalau ingin melihat semua ini bekerja sekaligus: jalankan <code>perf stat -e dTLB-load-misses,page-faults ./program</code>. Dua angka itu adalah harga langsung dari abstraksi virtual memory.}}

== Istilah kunci ==

; Virtual memory
: Abstraksi yang memberi tiap process ilusi penggunaan eksklusif atas main memory.
; Virtual address space
: Tampilan memory yang seragam yang dilihat tiap process.
; Heap
: Area yang memuai dan menyusut dinamis saat run time akibat <code>malloc</code> dan <code>free</code>.
; User stack
: Area di puncak ruang alamat user, dipakai compiler untuk mengimplementasikan pemanggilan fungsi.
; Shared library
: Code dan data pustaka bersama seperti libc dan libm, dipetakan di sekitar tengah ruang alamat.
; Kernel virtual memory
: Region teratas yang disediakan untuk kernel; tidak boleh dibaca, ditulis, atau dipanggil langsung oleh aplikasi.
; ASLR
: Pengacakan alamat basis region saat process dijalankan, sebagai pertahanan keamanan.

== Lihat juga ==

* [[Process]]
* [[Threads]]
* [[Files]]
* [[OS Manages Hardware]]
* [[System Call]]
* [[CS:APP]]

Virtual Memory

2026-08-24T04:26:59Z

SanzSkuy: Created page with "== Ilusi yang dijual == '''Virtual memory''' adalah abstraksi yang memberi tiap process ilusi bahwa dia '''punya akses eksklusif ke main memory'''. Tiap process melihat memory dengan '''tampilan yang seragam''', dan tampilan itu disebut '''virtual address space'''. Seragam artinya: process apa pun, sekecil atau sebesar apa pun, melihat peta memory dengan struktur yang sama persis. {{Catatan|Struktur pada Figure 1.13 adalah tata letak untuk process Linux. Sistem Unix l..."

== Ilusi yang dijual ==

'''Virtual memory''' adalah abstraksi yang memberi tiap process ilusi bahwa dia '''punya akses eksklusif ke main memory'''.

Tiap process melihat memory dengan '''tampilan yang seragam''', dan tampilan itu disebut '''virtual address space'''. Seragam artinya: process apa pun, sekecil atau sebesar apa pun, melihat peta memory dengan struktur yang sama persis.

{{Catatan|Struktur pada Figure 1.13 adalah tata letak untuk process Linux. Sistem Unix lain memakai layout yang mirip.}}

== Tata letak ruang alamat ==

Pembagian besarnya cuma dua:

* '''Region paling atas''' — disediakan untuk code dan data operating system, dan ini '''sama untuk semua process'''.
* '''Region bawah''' — menampung code dan data yang didefinisikan oleh process milik user.

{{Warning|title=Arah alamat|Pada Figure 1.13, '''alamat bertambah dari bawah ke atas'''. Angka 0 ada di dasar gambar. Jadi "stack di atas" berarti alamatnya tinggi, dan "heap di bawah" berarti alamatnya rendah. Salah baca arah ini bikin seluruh diagram jadi terbalik maknanya.}}

<pre>
alamat tinggi
+---------------------------------+
| Kernel virtual memory | <- tidak terlihat oleh user code
+---------------------------------+
| User stack |
| (dibuat saat run time) |
| | |
| v tumbuh turun |
+---------------------------------+
| (ruang kosong) |
+---------------------------------+
| Memory-mapped region |
| untuk shared libraries | <- di sini fungsi printf berada
+---------------------------------+
| (ruang kosong) |
| ^ tumbuh naik |
+---------------------------------+
| Run-time heap |
| (dibuat oleh malloc) |
+---------------------------------+
| Read/write data | \
+---------------------------------+ > dimuat dari file
| Read-only code and data | / executable hello
+---------------------------------+ <- program start
| |
+---------------------------------+ 0
alamat rendah
</pre>

== Area-area penting ==

Dibahas dari alamat terendah naik ke atas.

=== Program code and data ===

Code dimulai pada '''alamat tetap yang sama untuk semua process''', diikuti lokasi data yang berkorespondensi dengan variabel global C.

Yang khas dari area ini: isinya '''diinisialisasi langsung dari isi file executable object''' — dalam contoh kita, file <code>hello</code>. Jadi area ini bukan dibangun saat runtime, tapi disalin dari file di disk.

Ukurannya '''tetap begitu process mulai jalan'''.

Dibahas lebih lanjut di '''Bab 7''' (linking dan loading).

=== Heap ===

Langsung menyusul area code dan data. Berbeda dari code dan data yang ukurannya tetap, heap '''memuai dan menyusut secara dinamis saat run time''' sebagai akibat pemanggilan rutin pustaka standar C seperti <code>malloc</code> dan <code>free</code>.

Dibahas detail di '''Bab 9'''.

=== Shared libraries ===

Berada di '''sekitar tengah''' ruang alamat. Menampung code dan data untuk shared library seperti pustaka standar C dan pustaka matematika.

Inilah tempat fungsi <code>printf</code> yang dipanggil <code>hello</code> sebenarnya berada — bukan di dalam executable-nya sendiri.

CS:APP sendiri menyebut konsep shared library ini '''powerful tapi agak sulit'''. Mekanismenya dibahas di '''Bab 7''' (dynamic linking).

=== User stack ===

Berada di '''puncak ruang alamat user'''. Dipakai '''compiler untuk mengimplementasikan pemanggilan fungsi'''.

Seperti heap, stack juga memuai dan menyusut secara dinamis selama program berjalan:

* tiap kali kita '''memanggil''' fungsi → stack '''tumbuh'''
* tiap kali kita '''return''' dari fungsi → stack '''menyusut'''

Cara compiler memakai stack dibahas di '''Bab 3'''.

=== Kernel virtual memory ===

Region paling atas, disediakan untuk kernel. Aturannya tegas — program aplikasi '''tidak diizinkan''':

* membaca isi area ini
* menulis ke area ini
* memanggil langsung fungsi yang didefinisikan di kode kernel

Sebagai gantinya, aplikasi harus '''meminta kernel''' untuk melakukan operasi tersebut, yaitu lewat system call. Ini menyambung langsung ke pembahasan di [[Processes]].

== Cara kerjanya ==

Supaya virtual memory bisa bekerja, dibutuhkan '''interaksi yang rumit antara hardware dan software operating system''', termasuk '''penerjemahan alamat oleh hardware untuk setiap alamat yang dihasilkan processor'''.

Perhatikan kata '''setiap'''. Ini bukan operasi sesekali — tiap kali instruksi menyentuh memory, ada terjemahan alamat virtual ke alamat fisik yang terjadi di hardware.

Ide dasarnya:

# Simpan isi virtual memory sebuah process '''di disk'''.
# Gunakan '''main memory sebagai cache untuk disk''' itu.

{{Catatan|title=Model mental yang terbalik|Poin kedua ini biasanya yang paling mengejutkan. Kita terbiasa berpikir RAM sebagai tempat penyimpanan utama dan disk sebagai cadangan. Virtual memory membalik posisinya: disk adalah tempat data sebenarnya berada, dan RAM cuma lapisan cache yang cepat di depannya. Sudut pandang ini yang bikin konsep page fault jadi masuk akal.}}

Penjelasan lengkapnya, dan kenapa ini begitu penting untuk sistem modern, ada di '''Bab 9'''.

== Catatan untuk kerja systems ==

* '''"Code dimulai pada alamat tetap yang sama" sudah tidak sepenuhnya berlaku.''' Pernyataan itu benar untuk binary non-PIE. Linux modern mengompilasi binary sebagai PIE dan mengaktifkan '''ASLR''', sehingga alamat basis code, heap, stack, dan shared library diacak tiap kali process dijalankan — sebagai pertahanan terhadap eksploitasi. Cek dengan menjalankan <code>cat /proc/self/maps</code> dua kali dan bandingkan hasilnya. Untuk debugging bisa dimatikan sementara dengan <code>setarch -R</code>.
* '''Peta ini bisa dilihat langsung.''' <code>/proc/[pid]/maps</code> menampilkan seluruh region beserta permission dan file pendukungnya. Ini cara tercepat memverifikasi bahwa Figure 1.13 memang benar-benar ada, bukan sekadar model.
* '''Heap besar tidak selalu lewat heap.''' <code>malloc</code> di glibc memakai <code>brk</code> untuk alokasi kecil, tapi beralih ke <code>mmap</code> untuk alokasi di atas ambang tertentu (<code>M_MMAP_THRESHOLD</code>, default sekitar 128 KB). Jadi alokasi besar sebenarnya mendarat di region memory-mapped, bukan di run-time heap.
* '''Stack punya batas keras.''' Stack memang tumbuh otomatis, tapi hanya sampai <code>RLIMIT_STACK</code> (umumnya 8 MB). Di bawahnya ada ''guard page'' — menyentuhnya memicu SIGSEGV. Inilah yang terjadi pada rekursi tanpa henti.
* '''Alokasi tidak sama dengan memory fisik.''' Linux melakukan ''overcommit'': <code>malloc</code> yang sukses cuma berarti ruang alamat sudah dicadangkan, halaman fisiknya baru diberikan saat benar-benar disentuh (''demand paging''). Konsekuensinya, program bisa mati kena OOM killer di titik penulisan, bukan di titik alokasi.
* '''Terjemahan setiap alamat itu mahal, makanya ada TLB.''' Karena tiap akses memory butuh penerjemahan, hasil terjemahan di-cache di ''Translation Lookaside Buffer''. TLB miss adalah biaya nyata di workload dengan pola akses acak, dan itulah alasan ''huge pages'' bisa memberi percepatan besar di aplikasi seperti database dan HPC.

{{Tip|Kalau ingin melihat semua ini bekerja sekaligus: jalankan <code>perf stat -e dTLB-load-misses,page-faults ./program</code>. Dua angka itu adalah harga langsung dari abstraksi virtual memory.}}

== Istilah kunci ==

; Virtual memory
: Abstraksi yang memberi tiap process ilusi penggunaan eksklusif atas main memory.
; Virtual address space
: Tampilan memory yang seragam yang dilihat tiap process.
; Heap
: Area yang memuai dan menyusut dinamis saat run time akibat <code>malloc</code> dan <code>free</code>.
; User stack
: Area di puncak ruang alamat user, dipakai compiler untuk mengimplementasikan pemanggilan fungsi.
; Shared library
: Code dan data pustaka bersama seperti libc dan libm, dipetakan di sekitar tengah ruang alamat.
; Kernel virtual memory
: Region teratas yang disediakan untuk kernel; tidak boleh dibaca, ditulis, atau dipanggil langsung oleh aplikasi.
; ASLR
: Pengacakan alamat basis region saat process dijalankan, sebagai pertahanan keamanan.

== Lihat juga ==

* [[Process]]
* [[Threads]]
* [[OS Manages Hardware]]
* [[System Call]]
* [[CS:APP]]

Threads

2026-08-24T04:10:35Z

SanzSkuy:

== Pergeseran model mental ==

Sampai sini kita biasanya membayangkan process punya '''satu alur kontrol tunggal''' — satu PC yang bergerak dari instruksi ke instruksi.

Di sistem modern, kenyataannya lebih luas: sebuah process bisa terdiri dari '''beberapa unit eksekusi''' yang disebut '''thread'''. Masing-masing thread:

* jalan '''di dalam context process''' yang sama
* '''berbagi code dan global data''' yang sama

Jadi hubungannya bertingkat: OS punya banyak process, dan tiap process bisa punya banyak thread di dalamnya.

<pre>
+---------------------- Process ----------------------+
| |
| Code + Global data <- dibagi bersama |
| |
| +-----------+ +-----------+ +-----------+ |
| | Thread 1 | | Thread 2 | | Thread 3 | |
| | PC | | PC | | PC | |
| | Register | | Register | | Register | |
| | Stack | | Stack | | Stack | |
| +-----------+ +-----------+ +-----------+ |
| |
+-----------------------------------------------------+
</pre>

== Kenapa thread makin penting ==

CS:APP menyebut tiga alasan thread jadi model pemrograman yang makin sentral:

# '''Kebutuhan concurrency di network server.''' Server harus melayani banyak koneksi sekaligus. Model satu-thread-per-koneksi jauh lebih natural daripada memaksa semuanya masuk satu alur kontrol.
# '''Berbagi data antar thread lebih mudah daripada antar process.''' Karena thread satu process sudah otomatis berbagi ruang alamat, nggak perlu mekanisme IPC seperti pipe, shared memory segment, atau socket.
# '''Thread biasanya lebih efisien daripada process.''' Membuat thread lebih murah daripada membuat process, dan switching antar thread dalam satu process juga lebih ringan.

Selain itu, '''multi-threading adalah salah satu cara membuat program berjalan lebih cepat ketika tersedia beberapa processor''' — dibahas lebih jauh di §1.9.2.

{{Catatan|title=Dua motivasi yang berbeda|Perhatikan bahwa ada dua alasan berbeda untuk pakai thread. Yang pertama soal ''struktur program'' (concurrency: mengurus banyak hal yang saling menunggu), yang kedua soal ''kecepatan'' (parallelism: memakai lebih dari satu core). Program bisa butuh yang satu tanpa butuh yang lain.}}

== Sisi lain dari kemudahan berbagi ==

Poin nomor 2 di atas adalah pisau bermata dua, dan ini penting banget dipahami sejak awal.

Karena thread berbagi ruang alamat yang sama, dua thread bisa menulis ke variabel yang sama '''pada saat yang sama''' tanpa ada yang menghalangi. Hasilnya bergantung urutan eksekusi yang tidak kita kendalikan.

{{Warning|title=Harga dari sharing|Kemudahan berbagi data itu sekaligus sumber kelas bug paling sulit di pemrograman sistem: ''data race'', ''deadlock'', dan bug yang cuma muncul satu dari sejuta eksekusi. Isolasi antar process yang tadinya terasa merepotkan itu ternyata juga bentuk perlindungan.}}

Antar process, isolasi memory bikin bug semacam ini secara struktural mustahil terjadi. Antar thread, perlindungan itu hilang dan harus digantikan disiplin programmer plus mekanisme sinkronisasi.

== Apa yang dibagi, apa yang privat ==

Ringkasan pembagiannya (detailnya di Bab 12):

{| class="wikitable"
! Dibagi bersama seluruh thread !! Privat per thread
|-
| Code (text segment) || Program counter
|-
| Global data || Register file
|-
| Heap || Stack sendiri
|-
| File descriptor yang terbuka || Thread ID
|}

Aturan praktisnya: '''kalau datanya di stack, biasanya aman; kalau global atau di heap, hati-hati.'''

== Catatan untuk kerja systems ==

* '''"Thread lebih efisien" itu benar tapi ada batasnya.''' Membuat thread memang jauh lebih murah daripada membuat process, tapi tiap thread tetap butuh stack sendiri. Ribuan thread berarti ribuan stack — ini salah satu alasan model async/event-driven muncul untuk kasus koneksi sangat banyak.
* '''Switch antar thread satu process lebih murah karena page table-nya sama.''' Nggak ada penggantian CR3, jadi TLB nggak perlu di-flush total. Tapi cache tetap bisa terganggu.
* '''False sharing adalah jebakan performa klasik.''' Dua thread menulis ke variabel berbeda yang kebetulan berada di ''cache line'' yang sama akan saling membatalkan cache satu sama lain. Secara logika nggak ada konflik, secara hardware ada. Solusinya biasanya ''padding'' sampai batas cache line.
* '''Di HPC, thread biasanya di-pin ke core.''' OpenMP lewat <code>OMP_PROC_BIND</code> dan <code>OMP_PLACES</code>, atau <code>numactl</code>/<code>taskset</code> di level proses, supaya thread nggak berpindah core dan kehilangan lokalitas cache.
* '''Bahasa punya sikap berbeda soal ini.''' Rust memindahkan pengecekan keamanan thread ke ''compile time'' lewat trait <code>Send</code> dan <code>Sync</code>, sehingga banyak data race ditolak sebelum program jalan. Python sebaliknya membatasi eksekusi bytecode dengan GIL, sehingga thread bagus untuk I/O-bound tapi tidak memberi speedup untuk CPU-bound.

{{Tip|Kalau tujuannya cuma ''concurrency'' (banyak hal saling menunggu I/O), thread bukan satu-satunya jawaban — async runtime sering lebih hemat. Thread jadi wajib kalau tujuannya ''parallelism'' untuk kerja CPU-bound.}}

== Yang akan datang ==

Konsep dasar concurrency, termasuk cara menulis program ber-thread, dibahas di '''Bab 12'''. Diskusi soal memanfaatkan beberapa processor ada di '''§1.9.2'''.

== Istilah kunci ==

; Thread
: Unit eksekusi di dalam sebuah process; berjalan dalam context process itu dan berbagi code serta global data dengan thread lain.
; Multi-threading
: Menjalankan beberapa thread dalam satu process, salah satunya untuk memanfaatkan beberapa processor.
; Data race
: Kondisi ketika dua thread mengakses data yang sama tanpa sinkronisasi dan minimal satu di antaranya menulis.
; False sharing
: Penurunan performa akibat dua thread menulis ke variabel berbeda yang berada di cache line yang sama.

== Lihat juga ==

* [[Process]]
* [[OS Manages Hardware]]
* [[Virtual Memory]]
* [[CS:APP]]

Threads

2026-08-24T04:07:45Z

SanzSkuy:

== Pergeseran model mental ==

Sampai sini kita biasanya membayangkan process punya '''satu alur kontrol tunggal''' — satu PC yang bergerak dari instruksi ke instruksi.

Di sistem modern, kenyataannya lebih luas: sebuah process bisa terdiri dari '''beberapa unit eksekusi''' yang disebut '''thread'''. Masing-masing thread:

* jalan '''di dalam context process''' yang sama
* '''berbagi code dan global data''' yang sama

Jadi hubungannya bertingkat: OS punya banyak process, dan tiap process bisa punya banyak thread di dalamnya.

<pre>
+---------------------- Process ----------------------+
| |
| Code + Global data <- dibagi bersama |
| |
| +-----------+ +-----------+ +-----------+ |
| | Thread 1 | | Thread 2 | | Thread 3 | |
| | PC | | PC | | PC | |
| | Register | | Register | | Register | |
| | Stack | | Stack | | Stack | |
| +-----------+ +-----------+ +-----------+ |
| |
+-----------------------------------------------------+
</pre>

== Kenapa thread makin penting ==

CS:APP menyebut tiga alasan thread jadi model pemrograman yang makin sentral:

# '''Kebutuhan concurrency di network server.''' Server harus melayani banyak koneksi sekaligus. Model satu-thread-per-koneksi jauh lebih natural daripada memaksa semuanya masuk satu alur kontrol.
# '''Berbagi data antar thread lebih mudah daripada antar process.''' Karena thread satu process sudah otomatis berbagi ruang alamat, nggak perlu mekanisme IPC seperti pipe, shared memory segment, atau socket.
# '''Thread biasanya lebih efisien daripada process.''' Membuat thread lebih murah daripada membuat process, dan switching antar thread dalam satu process juga lebih ringan.

Selain itu, '''multi-threading adalah salah satu cara membuat program berjalan lebih cepat ketika tersedia beberapa processor''' — dibahas lebih jauh di §1.9.2.

{{Note|title=Dua motivasi yang berbeda|Perhatikan bahwa ada dua alasan berbeda untuk pakai thread. Yang pertama soal ''struktur program'' (concurrency: mengurus banyak hal yang saling menunggu), yang kedua soal ''kecepatan'' (parallelism: memakai lebih dari satu core). Program bisa butuh yang satu tanpa butuh yang lain.}}

== Sisi lain dari kemudahan berbagi ==

Poin nomor 2 di atas adalah pisau bermata dua, dan ini penting banget dipahami sejak awal.

Karena thread berbagi ruang alamat yang sama, dua thread bisa menulis ke variabel yang sama '''pada saat yang sama''' tanpa ada yang menghalangi. Hasilnya bergantung urutan eksekusi yang tidak kita kendalikan.

{{Warning|title=Harga dari sharing|Kemudahan berbagi data itu sekaligus sumber kelas bug paling sulit di pemrograman sistem: ''data race'', ''deadlock'', dan bug yang cuma muncul satu dari sejuta eksekusi. Isolasi antar process yang tadinya terasa merepotkan itu ternyata juga bentuk perlindungan.}}

Antar process, isolasi memory bikin bug semacam ini secara struktural mustahil terjadi. Antar thread, perlindungan itu hilang dan harus digantikan disiplin programmer plus mekanisme sinkronisasi.

== Apa yang dibagi, apa yang privat ==

Ringkasan pembagiannya (detailnya di Bab 12):

{| class="wikitable"
! Dibagi bersama seluruh thread !! Privat per thread
|-
| Code (text segment) || Program counter
|-
| Global data || Register file
|-
| Heap || Stack sendiri
|-
| File descriptor yang terbuka || Thread ID
|}

Aturan praktisnya: '''kalau datanya di stack, biasanya aman; kalau global atau di heap, hati-hati.'''

== Catatan untuk kerja systems ==

* '''"Thread lebih efisien" itu benar tapi ada batasnya.''' Membuat thread memang jauh lebih murah daripada membuat process, tapi tiap thread tetap butuh stack sendiri. Ribuan thread berarti ribuan stack — ini salah satu alasan model async/event-driven muncul untuk kasus koneksi sangat banyak.
* '''Switch antar thread satu process lebih murah karena page table-nya sama.''' Nggak ada penggantian CR3, jadi TLB nggak perlu di-flush total. Tapi cache tetap bisa terganggu.
* '''False sharing adalah jebakan performa klasik.''' Dua thread menulis ke variabel berbeda yang kebetulan berada di ''cache line'' yang sama akan saling membatalkan cache satu sama lain. Secara logika nggak ada konflik, secara hardware ada. Solusinya biasanya ''padding'' sampai batas cache line.
* '''Di HPC, thread biasanya di-pin ke core.''' OpenMP lewat <code>OMP_PROC_BIND</code> dan <code>OMP_PLACES</code>, atau <code>numactl</code>/<code>taskset</code> di level proses, supaya thread nggak berpindah core dan kehilangan lokalitas cache.
* '''Bahasa punya sikap berbeda soal ini.''' Rust memindahkan pengecekan keamanan thread ke ''compile time'' lewat trait <code>Send</code> dan <code>Sync</code>, sehingga banyak data race ditolak sebelum program jalan. Python sebaliknya membatasi eksekusi bytecode dengan GIL, sehingga thread bagus untuk I/O-bound tapi tidak memberi speedup untuk CPU-bound.

{{Tip|Kalau tujuannya cuma ''concurrency'' (banyak hal saling menunggu I/O), thread bukan satu-satunya jawaban — async runtime sering lebih hemat. Thread jadi wajib kalau tujuannya ''parallelism'' untuk kerja CPU-bound.}}

== Yang akan datang ==

Konsep dasar concurrency, termasuk cara menulis program ber-thread, dibahas di '''Bab 12'''. Diskusi soal memanfaatkan beberapa processor ada di '''§1.9.2'''.

== Istilah kunci ==

; Thread
: Unit eksekusi di dalam sebuah process; berjalan dalam context process itu dan berbagi code serta global data dengan thread lain.
; Multi-threading
: Menjalankan beberapa thread dalam satu process, salah satunya untuk memanfaatkan beberapa processor.
; Data race
: Kondisi ketika dua thread mengakses data yang sama tanpa sinkronisasi dan minimal satu di antaranya menulis.
; False sharing
: Penurunan performa akibat dua thread menulis ke variabel berbeda yang berada di cache line yang sama.

== Lihat juga ==

* [[Process]]
* [[OS Manages Hardware]]
* [[Virtual Memory]]
* [[CS:APP]]