---
# System prepended metadata

title: IOT_TP_Modul4

---

---
title: TP_Modul4

---

# TP Modul 4 - Deadlock & Synchronization 
Pembuat: NS

```
Nama  : Salim
NPM   : 2306204604
```

**JAWABAN TANPA REFERENSI YANG SESUAI DIANGGAP MENDAPATKAN 0 POIN (UNLESS SPECIFIED OTHERWISE)**

### A. Teori dan Analisis (60 poin)

1. Jelaskan bagaimana sebuah prosesor single-core memberikan ilusi eksekusi paralel dan bandingkan dengan arsitektur multi-core! [10 poin]
sebuah prosesor single-core memberikan ilusi eksekusi paralel dengan memberikan context switching dengan mengganti task yang dieksekusi dalam beberapa waktu tertentu membuat seolah-olah eksekusi dilakukan secara paralel.
Berbeda dengan arsitektur single-core, arsitektur multi-core dapat menjalankan banyak task secara bersamaan.

**Referensi**
- [1]M. Costa, “Concurrency and Parallelism: An Overview,” DEV Community, Feb. 13, 2023. https://dev.to/costamatheus97/concurrency-and-parallelism-an-overview-4jam
- [2]GeeksforGeeks, “Difference between Concurrency and Parallelism,” GeeksforGeeks, Oct. 09, 2019. https://www.geeksforgeeks.org/operating-systems/difference-between-concurrency-and-parallelism/

2. Jelaskan bagaimana interaksi antar task yang berjalan secara konkuren dapat menimbulkan masalah Race Condition saat mengakses shared resources[10 poin]
Interaksi antar yang berjalan secara konkuren dapat menimbulkan masalah Race Condition saat mengakses shared resources karena urutan eksekusi task berjalan secara paralel sehingga hasil program tidak konsisten karena urutan eksekusi task tidak dapat diprediksi

**Referensi**
- [3]R. H. B. Netzer and B. P. Miller, “What are race conditions?,” ACM Letters on Programming Languages and Systems, vol. 1, no. 1, pp. 74–88, Mar. 1992, doi: https://doi.org/10.1145/130616.130623.
- [4]GeeksforGeeks, “Race Condition Vulnerability,” GeeksforGeeks, Dec. 20, 2020. https://www.geeksforgeeks.org/operating-systems/race-condition-vulnerability/

3. Jelaskan cara kerja mutex dan bagaimana hal tersebut dapat mencegah race condition. [10 poin]
Mutex bekerja dengan hanya memberikan akses data pada task yang sedang memiliki mutex tersebut sedangkan task lain harus menunggu mutex dilepas oleh task yang sedang memegang mutex tersebut.
Mutex mencegah race condition karena hanya satu task yang dapat mengakses tertentu sehingga tidak dua task yang mengakses data yang sama secara bersamaan yang menyebabkan race condition

**Referensi**
- [5]Kerala Blockchain Academy, “What is mutex? How does it prevent race conditions?,” Medium, Oct. 04, 2024. https://kbaiiitmk.medium.com/what-is-mutex-how-does-it-prevent-race-conditions-6cf59e0dda6e
- [6]GeeksforGeeks, “Race Condition Vulnerability,” GeeksforGeeks, Dec. 20, 2020. https://www.geeksforgeeks.org/operating-systems/race-condition-vulnerability/

4. Penggunaan mutex dapat menimbulkan masalah baru, yaitu Priority Inversion. Jelaskan apa itu Priority Inversion dengan memberikan skenario yang melibatkan tiga task (prioritas rendah, sedang, dan tinggi). [10 poin]
Priority Inversion adalah masalah sebuah task yang berprioritas tinggi tidak bisa dieksekusi karena sedang menunggu mutex yang sedang dipegang oleh task dengan prioritas rendah. Akan tetapi, task dengan prioritas rendah kesulitan menyelesaikan proses eksekusinya karena task dengan prioritas sedang sedang berjalan.

**Referensi**
- [7]GeeksforGeeks, “Priority Inversion in Operating Systems,” GeeksforGeeks, Sep. 14, 2015. https://www.geeksforgeeks.org/operating-systems/priority-inversion/
- [8]S. Hymel, “Introduction to RTOS - Solution to Part 11 (Priority Inversion),” www.digikey.com. https://www.digikey.com/en/maker/projects/introduction-to-rtos-solution-to-part-11-priority-inversion/abf4b8f7cd4a4c70bece35678d178321

5. Bandingkan dan jelaskan perbedaan dari Mutex dan Binary Semaphore! [10 poin]
Terdapat beberapa perbedaan dari Mutex dan Binary Semaphore. Mutex hanya dapat dimiliki oleh task yang sedang mengunci mutex sedangkan binary semaphore tidak memiliki pemilik. Terdapat berbagai task yang dapat mengakses binary semaphore secara concurrent sedangkan mutex hanya dapat diakses satu task dalam satu waktu. Binary semaphore dapat dilepas oleh task manapun sedangkan mutex hanya dapat dilepas oleh yang mengunci mutex tersebut.

**Referensi**
- [9]GeeksforGeeks, “Difference between Binary Semaphore and Mutex,” GeeksforGeeks, Aug. 18, 2020. https://www.geeksforgeeks.org/operating-systems/difference-between-binary-semaphore-and-mutex/
- [10]baeldung, “Semaphore vs. Mutex | Baeldung on Computer Science,” www.baeldung.com, Mar. 19, 2021. https://www.baeldung.com/cs/semaphore-vs-mutex

6. Dalam menerapkan critical section, terdapat dua metode paling dasar dalam FreeRTOS yang dapat digunakan, yaitu macro (`taskENTER_CRITICAL()` dan `taskEXIT_CRITICAL()`) dan Mutex. Jelaskan pro dan kontra dari masing masing metode [10 poin].
Pada metode critical section, yang dilakukan hanyalah menonaktifkan interrupt sehingga dapat dijalankan dengan cepat. Namun, jika digunakan terlalu lama akan memengaruhi jalannya program karena tidak dapat melakukan interrupt. Pada mutex, interrupt tidak dinonaktifkan dan juga dapat mencegah priority inversion. Hanya saja, membutuhkan waktu yang lebih lama untuk menggunakan mutex dibandingkan dengan menggunakan critical section pada FreeRTOS.

**Referensi**
- [11]I. Finlayson, “Critical Sections & Mutexes,” Ianfinlayson.net, 2025. https://ianfinlayson.net/class/cpsc425/notes/05-mutexes (accessed Sep. 25, 2025).
- [12]“taskENTER_CRITICAL(), taskEXIT_CRITICAL() - FreeRTOSTM,” Freertos.org, 2025. https://freertos.org/Documentation/02-Kernel/04-API-references/04-RTOS-kernel-control/01-taskENTER_CRITICAL_taskEXIT_CRITICAL (accessed Sep. 25, 2025).

### B. Praktik (40 poin) [Bagian B tidak memperlukan referensi]
Buatlah sebuah program yang mensimulasikan adanya Race Condition dan cara mengatasinya menggunakan Mutex. Program ini akan melibatkan dua buah task yang memodifikasi sebuah global variable secara bersamaan. Program harus terdiri dari :
   - Sebuah global variable `int counter`.
   - Task 1:
     - Membaca nilai `int counter`
     - Melakukan delay 100 Tick.
     - Increment nilai dari pembacaan `int counter` sebelumnya dan assign nilai tersebut ke `int counter`.
     - Print nilai `int counter` dengan format `Task 1: counter = [nilai counter]`
   - Task 2:
     - Membaca nilai `int counter`
     - Melakukan delay 100 Tick.
     - Decrement nilai dari pembacaan `int counter` sebelumnya dan assign nilai tersebut ke `int counter`.
     - Print nilai `int counter` dengan format `Task 2: counter = [nilai counter]`
   - Priority Task 1 dan Task 2 dibuat sama.
   - Task 1 dijalankan pada core 0, sedangkan Task 2 dijalankan pada core 1

1. Buatlah Kode untuk program tersebut! [20 poin]
Kode:
```cpp=
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

int counter = 0;

TaskHandle_t xTask1Handle  = NULL;
TaskHandle_t xTask2Handle  = NULL;

void task1(void *pv) {
  while(1) {
    int temp = counter;
    vTaskDelay(100);
    counter = temp + 1;
    Serial.printf("Task 1: counter = %d\n", counter);
  }
}

void task2(void *pv) {
  while(1) {
    int temp = counter;
    vTaskDelay(100);
    counter = temp - 1;
    Serial.printf("Task 2: counter = %d\n", counter);
  }
}

void setup() {
  Serial.begin(115200);

  const UBaseType_t PRIO_TASK1 = 1;
  const UBaseType_t PRIO_TASK2 = 1;

  const uint32_t STACK_WORDS = 2048;

  xTaskCreatePinnedToCore(
    task1,
    "Task 1",
    STACK_WORDS,
    NULL,
    PRIO_TASK1,
    &xTask1Handle,
    0);
    
  xTaskCreatePinnedToCore(
    task2,
    "Task 2",
    STACK_WORDS,
    NULL,
    PRIO_TASK2,
    &xTask2Handle,
    1);
}

void loop() {
}
```
2. Tunjukan race condition yang terjadi dan jelaskan mengapa hal tersebut terjadi (Sertakan screenshot) [5 poin]
Hal tersebut terjadi karena task menggunakan nilai counter saat sebelum diganti oleh task lain sehingga nilai counter diubah oleh task tersebut tanpa memperhatikan perubahan nilai counter yang telah dilakukan oleh task lain.
Screenshot:
![image](https://hackmd.io/_uploads/Syh9e0z2xl.png)

3. Implementasikan solusi untuk menyelesaikan masalah diatas dan berikan kode yang baru! [10 poin]
Kode:
```cpp=
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"

int counter = 0;
SemaphoreHandle_t mutex;

TaskHandle_t xTask1Handle  = NULL;
TaskHandle_t xTask2Handle  = NULL;

void task1(void *pv) {
  while(1) {
    if (xSemaphoreTake(mutex, portMAX_DELAY) == pdTRUE) {
      int temp = counter;
      vTaskDelay(100);
      counter = temp + 1;
      Serial.printf("Task 1: counter = %d\n", counter);
      xSemaphoreGive(mutex);
    }
    vTaskDelay(10);
  }
}

void task2(void *pv) {
  while(1) {
    if (xSemaphoreTake(mutex, portMAX_DELAY) == pdTRUE) {
      int temp = counter;
      vTaskDelay(100);
      counter = temp - 1;
      Serial.printf("Task 2: counter = %d\n", counter);
      xSemaphoreGive(mutex);
    }
    vTaskDelay(10);
  }
}

void setup() {
  Serial.begin(115200);
    
  const UBaseType_t PRIO_TASK1 = 1;
  const UBaseType_t PRIO_TASK2 = 1;

  const uint32_t STACK_WORDS = 2048;

  mutex = xSemaphoreCreateMutex();
  if (mutex != NULL) {
    xTaskCreatePinnedToCore(
      task1,
      "Task 1",
      STACK_WORDS,
      NULL,
      PRIO_TASK1,
      &xTask1Handle,
      0);
      
    xTaskCreatePinnedToCore(
      task2,
      "Task 2",
      STACK_WORDS,
      NULL,
      PRIO_TASK2,
      &xTask2Handle,
      1);
  }
}

void loop() {
}
```
4. Jelaskan solusi yang anda terapkan untuk menyelesaikan masalah diatas [5 poin]
Solusi yang diterapkan adalah dengan menerapkan mutex dengan setiap task akan mengunci mutex saat mengakses nilai counter dan melepaskannya setelah meletakkan kembali nilai counter tersebut. Selain itu, juga ditambahkan sedikit delay setelah melepaskan mutex agar task lain dapat mengunci mutex tersebut.
Screenshot:
![image](https://hackmd.io/_uploads/Bkjwr0M2lg.png)
