FIFO algoritmasını daha iyi anlamak için resimli bir gösterim.FIFO algoritmasının temsili resmi.
**FIFO** (first-in, first-out; ilk giren ilk çıkar) algoritmasının mantığı basittir. Bellek yöneticisinin yeni bir sayfaya yer açmak için, hangi sayfayı dışarıda bırakacağını karar veren algoritmalardan biridir. Yönlendiriciye gelen ilk paket, iletilecek ilk pakettir.

FIFO kuyruğuna ilk gelen, ilk hizmet (first-come, first-served; FCFS) kuyruğu olarak da anıldığı unutmamalıdır. FCFS aynı zamanda FIFO işletim sistemi çizelgeleme algoritması için bir jargon terimidir. Ayrıca her işlem için merkezi işlem birimi (CPU) zamanını talep edildiği sırada vermektedir.

En basit algoritmalardan olan FIFO'nun uygulanması kolaydır ve yazılım tabanlı yönlendiriciler için düşük bir sistem yükü sunmaktadır. FIFO'nun tam tersi, en geç girişin veya "yığının tepesinin" ilk önce işlendiği, en son giren ilk çıkar algoritması olarak bilinen LIFO'dur (last-in-first-out)..

Bilgisayar bilimi
-----------------

Kuyruğa koyma ve kuyruktan çıkarma işlemleriyle bir FIFO kuyruğunun temsili.Kuyruğa koyma ve kuyruktan çıkarma işlemleriyle bir FIFO kuyruğunun temsili.
Uygulamaya bağlı olarak, bir FIFO, bir donanım kaydırma yazmacı olarak veya farklı bellek yapıları, tipik olarak dairesel bir tampon veya bir tür liste kullanarak uygulanabilmektedir. Bir FIFO kuyruğunun çoğu yazılım uygulaması iş parçacığı açısından güvenli değildir ve veri yapısı zincirinin aynı anda yalnızca bir iş parçacığı tarafından değiştirildiğini doğrulamak için bir kilitleme mekanizması gerektirmektedir.

FIFO algoritması farklı programlama dillerinde yazılabilmektedir. Örneğin;

### C++

```
// FIFO sayfa değiştirmenin C ++ uygulaması
// İşletim Sistemlerinde.
#include<bits/stdc++.h>
using namespace std;
 
// FIFO kullanarak sayfa hatalarını bulma işlevi
int pageFaults(int pages[], int n, int capacity)
{
 // Mevcut sayfalar kümesini temsil etmek için. 
 // Bir sayfanın kümede olup olmadığını hızlı bir şekilde kontrol etmek için 
 // unordered\_set kullanıyoruz
 unordered\_set<int> s;
 
 // Sayfaları FIFO tarzında saklamak için
 queue<int> indexes;
 
 // İlk sayfadan başlayın
 int page\_faults = 0;
 for (int i=0; i<n; i++)
 {
 // Setin daha fazla sayfa tutup tutamayacağını kontrol edin
 if (s.size() < capacity)
 {
 // Zaten yoksa, sayfa hatasını temsil eden sete ekleyin
 if (s.find(pages[i])==s.end())
 {
 // Mevcut sayfayı sete ekle
 s.insert(pages[i]);
 
 // artan sayfa hatası
 page\_faults++;
 
 // Mevcut sayfayı kuyruğa itin
 indexes.push(pages[i]);
 }
 }
 
 //Küme doluysa, FIFO gerçekleştirmeniz gerekir, 
 //yani kuyruğun ilk sayfasını kümeden kaldırın
 //ve her ikisini de sıraya koyun ve geçerli sayfayı ekleyin
 else
 {
 // Mevcut sayfanın sette zaten mevcut olup olmadığını kontrol edin
 if (s.find(pages[i]) == s.end())
 {
 // Sayfayı gruptan bulmak ve 
 // silmek için kullanılmak üzere sıradaki ilk sayfayı saklayın
 int val = indexes.front();
 
 // Sıradan ilk sayfayı aç
 indexes.pop();
 
 // Dizinler sayfasını kümeden kaldırın
 s.erase(val);
 
 // mevcut sayfayı sete ekle
 s.insert(pages[i]);
 
 //mevcut sayfayı kuyruğa it
 indexes.push(pages[i]);
 
 // artan sayfa hatası
 page\_faults++;
 }
 }
 }
 
 return page\_faults;
}
 
// Kodları çalıştıralım
int main()
{
 int pages[] = {7, 0, 1, 2, 0, 3, 0, 4,
 2, 3, 0, 3, 2};
 int n = sizeof(pages)/sizeof(pages[0]);
 int capacity = 4;
 cout << pageFaults(pages, n, capacity);
 return 0;
}

```

### Python

```
# FIFO sayfasının Python3 uygulaması
# İşletim Sistemlerinde değiştirme.
from queue import Queue 
  
# FIFO kullanarak sayfa hatalarını bulma işlevi
def pageFaults(pages, n, capacity):
      
    # Mevcut sayfaları temsil etmek için. 
    # Bir sayfanın kümede olup olmadığını hızlı bir şekilde kontrol etmek 
    # için set kullanıyoruz
    s = set() 
  
    # Sayfaları FIFO tarzında saklamak için 
    indexes = Queue() 
  
    # İlk sayfadan başlayın
    page\_faults = 0
    for i in range(n):
          
        #Setin daha fazla sayfa tutup tutamayacağını kontrol edin
        if (len(s) < capacity):
              
            # Zaten yoksa, sayfa hatasını temsil eden sete ekleyin
            if (pages[i] not in s):
                s.add(pages[i]) 
  
                # Sayfa hatalarını artırın
                page\_faults += 1
  
                # Mevcut sayfayı kuyruğa itin 
                indexes.put(pages[i])
  
        # Küme doluysa, FIFO gerçekleştirmeniz gerekir, 
        # yani kuyruğun ilk sayfasını kümeden kaldırın 
        # ve her ikisini de sıraya koyun ve geçerli sayfayı ekleyin 
        else:
              
            # Mevcut sayfanın sette zaten mevcut olup olmadığını kontrol edin 
            if (pages[i] not in s):
                  
                # Sıradan ilk sayfayı aç
                val = indexes.queue[0] 
  
                indexes.get() 
  
                # Dizinler sayfasını kaldırın 
                s.remove(val) 
  
                # mevcut sayfayı ekle
                s.add(pages[i]) 
  
                # mevcut sayfayı kuyruğa it 
                indexes.put(pages[i]) 
  
                # Sayfa hatalarını artırın
                page\_faults += 1
  
    return page\_faults
  
# Kodu çalıştırın
if \_\_name\_\_ == '\_\_main\_\_':
    pages = [7, 0, 1, 2, 0, 3, 0, 
                4, 2, 3, 0, 3, 2] 
    n = len(pages) 
    capacity = 4
    print(pageFaults(pages, n, capacity))

```

Disk denetleyicileri, FIFO'yu disk I/O isteklerine hizmet verilecek sırayı belirlemek için bir disk zamanlama algoritması olarak kullanabilmektedir. Burada, daha önce bahsedilen CPU zamanlamasında olduğu gibi aynı FCFS başlatması ile de bilinmektedir.

Bilgisayar ağlarında kullanılan iletişim ağı köprüleri, anahtarları ve yönlendiricileri, veri paketlerini bir sonraki hedeflerine doğru yolda tutmak için FIFO'ları kullanmaktadır. Tipik olarak ağ bağlantısı başına en az bir FIFO yapısı kullanılmaktadır. Bazı cihazlarda, farklı bilgi türlerini eşzamanlı ve bağımsız olarak sıraya koymak için birden çok FIFO bulunmaktadır.

Kaynakça
--------

1. ↑  "FIFO sayfa yer değiştirme algoritması (FIFO-First in First out page replace algorithm) | omurserdar.com". *www.omurserdar.com*. 25 Mayıs 2021 tarihinde kaynağından arşivlendi. Erişim tarihi: 25 Mayıs 2021.
2. ↑  *Packet Queueing and Scheduling* (İngilizce). Morgan Kaufmann. 1 Ocak 2018. ISBN 978-0-12-800737-2. 25 Mayıs 2021 tarihinde kaynağından arşivlendi. Erişim tarihi: 25 Mayıs 2021.
3. 1 2  Tanenbaum, Andrew S. (2015). *Modern operating systems*. Fourth edition. Boston. ISBN 978-0-13-359162-0. OCLC 870646449. 26 Ağustos 2022 tarihinde kaynağından arşivlendi. Erişim tarihi: 25 Mayıs 2021.
4. ↑  Kruse, Robert L. (1987). *Data structures and program design*. 2nd ed. Englewood Cliffs, N.J.: Prentice-Hall. ISBN 0-13-195884-4. OCLC 13823328.
5. 1 2  "Program for Page Replacement Algorithms | Set 2 (FIFO)". *GeeksforGeeks* (İngilizce). 17 Haziran 2017. 20 Haziran 2017 tarihinde kaynağından arşivlendi. Erişim tarihi: 25 Mayıs 2021.
6. ↑  Kurose, James F. (2006). *Computer networking : complete package*. 3rd ed. rev. Keith W. Ross. Harlow: Addison-Wesley. ISBN 0-321-41849-2. OCLC 70403052.

|  |  |
| --- | --- |
| Otorite kontrolü Bunu Vikiveri'de düzenleyin | 
* GND: 4419565-5

 |