JavaScript Modül Worker İş Parçacığı Havuzu: Verimli İş Parçacığı Yönetimi

Modern JavaScript uygulamaları, hesaplama açısından yoğun görevlerle veya G/Ç (Girdi/Çıktı) sınırlı işlemlerle uğraşırken sıklıkla performans darboğazlarıyla karşılaşır. JavaScript'in tek iş parçacıklı yapısı, çok çekirdekli işlemcileri tam olarak kullanma yeteneğini sınırlayabilir. Neyse ki, Node.js'deki Worker Threads ve tarayıcılardaki Web Workers'ın tanıtılması, paralel yürütme için bir mekanizma sağlayarak JavaScript uygulamalarının birden fazla CPU çekirdeğinden yararlanmasını ve yanıt verme yeteneğini iyileştirmesini sağlar.

Bu blog yazısı, iş parçacığı havuzlarını verimli bir şekilde yönetmek ve kullanmak için güçlü bir kalıp olan JavaScript Modül Worker İş Parçacığı Havuzu kavramını derinlemesine inceliyor. Bir iş parçacığı havuzu kullanmanın faydalarını keşfedeceğiz, uygulama ayrıntılarını tartışacağız ve kullanımını göstermek için pratik örnekler sunacağız.

Worker Thread Kavramını Anlamak

Bir worker thread havuzunun ayrıntılarına dalmadan önce, JavaScript'teki worker thread'lerin temellerini kısaca gözden geçirelim.

Worker Thread Nedir?

Worker thread'ler, ana iş parçacığıyla eşzamanlı olarak çalışabilen bağımsız JavaScript yürütme bağlamlarıdır. Ana iş parçacığını engellemeden ve kullanıcı arayüzü donmalarına veya performans düşüşlerine neden olmadan paralel görevler yürütmek için bir yol sağlarlar.

Worker Türleri

• Web Workers: Web tarayıcılarında bulunur ve kullanıcı arayüzü ile etkileşime girmeden arka plan betik yürütülmesine izin verir. Ağır hesaplamaları ana tarayıcı iş parçacığından boşaltmak için çok önemlidirler.
• Node.js Worker Threads: Node.js'de tanıtıldı ve sunucu tarafı uygulamalarda JavaScript kodunun paralel yürütülmesini sağlıyor. Bu, özellikle görüntü işleme, veri analizi veya birden çok eşzamanlı isteği işleme gibi görevler için önemlidir.

Temel Kavramlar

• Yalıtım: Worker thread'ler, paylaşılan verilere doğrudan erişimi engelleyerek ana iş parçacığından ayrı bellek alanlarında çalışır.
• Mesajlaşma: Ana iş parçacığı ve worker thread'ler arasındaki iletişim, asenkron mesajlaşma yoluyla gerçekleşir. Veri göndermek için postMessage() yöntemi kullanılır ve veri almak için onmessage olay işleyicisi kullanılır. Thread'ler arasında veri aktarılırken verilerin serileştirilmesi/deserileştirilmesi gerekir.
• Modül Workers: ES modülleri (import/export sözdizimi) kullanılarak oluşturulan worker'lar. Klasik betik worker'larına kıyasla daha iyi kod organizasyonu ve bağımlılık yönetimi sunarlar.

Worker Thread Havuzu Kullanmanın Faydaları

Worker thread'ler paralel yürütme için güçlü bir mekanizma sunarken, bunları doğrudan yönetmek karmaşık ve verimsiz olabilir. Her görev için worker thread oluşturmak ve yok etmek önemli bir ek yük getirebilir. İşte burada bir worker thread havuzu devreye girer.

Bir worker thread havuzu, önceden oluşturulmuş ve canlı tutulan ve görevleri yürütmeye hazır worker thread'lerden oluşan bir koleksiyondur. Bir görevin işlenmesi gerektiğinde, havuzdan atanır ve bu da onu uygun bir worker thread'e atar. Görev tamamlandığında, worker thread başka bir görevi işlemek üzere hazır bir şekilde havuza döner.

Bir worker thread havuzu kullanmanın avantajları:

• Azaltılmış Ek Yük: Mevcut worker thread'leri yeniden kullanarak, her görev için thread oluşturma ve yok etme ek yükü ortadan kaldırılır, bu da özellikle kısa ömürlü görevler için önemli performans iyileştirmeleri sağlar.
• Geliştirilmiş Kaynak Yönetimi: Havuz, aşırı kaynak tüketimini ve potansiyel sistem aşırı yüklenmesini önleyerek eşzamanlı worker thread sayısını sınırlar. Bu, yoğun yük altında kararlılığı sağlamak ve performans düşüşünü önlemek için çok önemlidir.
• Basitleştirilmiş Görev Yönetimi: Havuz, görevleri yönetmek ve zamanlamak için merkezi bir mekanizma sağlar, uygulama mantığını basitleştirir ve kod bakımını iyileştirir. Bireysel worker thread'leri yönetmek yerine, havuzla etkileşim kurarsınız.
• Kontrollü Eşzamanlılık: Paralellik derecesini sınırlamak ve kaynak tükenmesini önlemek için havuzu belirli sayıda iş parçacığıyla yapılandırabilirsiniz. Bu, mevcut donanım kaynaklarına ve iş yükünün özelliklerine göre performansı ince ayar yapmanıza olanak tanır.
• Geliştirilmiş Yanıt Verme: Görevleri worker thread'lere boşaltarak, ana iş parçacığı duyarlı kalır ve sorunsuz bir kullanıcı deneyimi sağlar. Kullanıcı arayüzü yanıt verme yeteneğinin kritik olduğu etkileşimli uygulamalar için bu özellikle önemlidir.

JavaScript Modül Worker İş Parçacığı Havuzu Uygulaması

Bir JavaScript Modül Worker İş Parçacığı Havuzunun uygulamasını inceleyelim. Uygulama ayrıntılarını göstermek için çekirdek bileşenleri kapsayacak ve kod örnekleri sunacağız.

Çekirdek Bileşenler

• Worker Havuzu Sınıfı: Bu sınıf, worker thread havuzunu yönetme mantığını kapsüller. Worker thread'leri oluşturmaktan, başlatmaktan ve geri dönüştürmekten sorumludur.
• Görev Kuyruğu: Yürütülmeyi bekleyen görevleri tutmak için bir kuyruk. Görevler havuza gönderildiğinde kuyruğa eklenir.
• Worker Thread Sarmalayıcısı: Yerel worker thread nesnesi etrafında, worker ile etkileşim kurmak için kullanışlı bir arayüz sağlayan bir sarmalayıcı. Bu sarmalayıcı, mesajlaşmayı, hata işlemeyi ve görev tamamlama takibini yönetebilir.
• Görev Gönderme Mekanizması: Havuza görev göndermek için bir mekanizma, tipik olarak Worker Havuzu sınıfındaki bir yöntem. Bu yöntem, görevi kuyruğa ekler ve görevi uygun bir worker thread'e ataması için havuzu tetikler.

Kod Örneği (Node.js)

Modül worker'ları kullanan Node.js'de basit bir worker thread havuzu uygulamasının örneği burada verilmiştir:

// worker_pool.js
import { Worker } from 'worker_threads';

class WorkerPool {
  constructor(numWorkers, workerFile) {
    this.numWorkers = numWorkers;
    this.workerFile = workerFile;
    this.workers = [];
    this.taskQueue = [];
    this.availableWorkers = [];

    for (let i = 0; i < numWorkers; i++) {
      const worker = new Worker(workerFile, { type: 'module' });
      const workerWrapper = {
        worker,
        isBusy: false
      };
      this.workers.push(workerWrapper);
      this.availableWorkers.push(workerWrapper);

      worker.on('message', (message) => {
        // Görev tamamlama işle
        workerWrapper.isBusy = false;
        this.availableWorkers.push(workerWrapper);
        this.processTaskQueue();
      });

      worker.on('error', (error) => {
        console.error('Worker hatası:', error);
      });

      worker.on('exit', (code) => {
        if (code !== 0) {
          console.error(`Worker ${code} exit koduyla durdu`);
        }
      });
    }
  }

  runTask(task) {
    return new Promise((resolve, reject) => {
      this.taskQueue.push({ task, resolve, reject });
      this.processTaskQueue();
    });
  }

  processTaskQueue() {
    if (this.taskQueue.length === 0 || this.availableWorkers.length === 0) {
      return;
    }

    const workerWrapper = this.availableWorkers.shift();
    const { task, resolve, reject } = this.taskQueue.shift();

    workerWrapper.isBusy = true;
    workerWrapper.worker.postMessage(task);

    workerWrapper.worker.once('message', (result) => {
      resolve(result);
    });

    workerWrapper.worker.once('error', (error) => {
      reject(error);
    });

  }

  close() {
    this.workers.forEach(workerWrapper => workerWrapper.worker.terminate());
  }
}

export default WorkerPool;

// worker.js
import { parentPort } from 'worker_threads';

parentPort.on('message', (task) => {
  // Hesaplama yoğunluğu olan bir görev simülasyonu
  const result = task * 2; // Gerçek görev mantığınızı burayla değiştirin
  parentPort.postMessage(result);
});

// main.js
import WorkerPool from './worker_pool.js';

const numWorkers = 4; // CPU sayı sayınıza göre ayarlaın
const workerFile = './worker.js';

const pool = new WorkerPool(numWorkers, workerFile);

async function main() {
  const tasks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

  const results = await Promise.all(
    tasks.map(async (task) => {
      try {
        const result = await pool.runTask(task);
        console.log(`Görev ${task} sonucu: ${result}`);
        return result;
      } catch (error) {
        console.error(`Görev ${task} başarısız oldu:`, error);
        return null;
      }
    })
  );

  console.log('Tüm görevler tamamlandı:', results);

  pool.close(); // Havuzdaki tüm worker'ları sonlandır
}

main();

Açıklama:

• worker_pool.js: Worker thread oluşturmayı, görev kuyruğunu ve görev atamasını yöneten WorkerPool sınıfını tanımlar. runTask yöntemi bir görevi kuyruğa gönderir ve processTaskQueue görevleri uygun worker'lara atar. Ayrıca worker hatalarını ve çıkışlarını da ele alır.
• worker.js: Bu worker thread kodudur. parentPort.on('message') kullanarak ana iş parçacığından gelen mesajları dinler, görevi gerçekleştirir ve sonucu parentPort.postMessage() kullanarak geri gönderir. Sağlanan örnek, alınan görevi yalnızca 2 ile çarpar.
• main.js: WorkerPool'un nasıl kullanılacağını gösterir. Belirli sayıda worker ile bir havuz oluşturur ve pool.runTask() kullanarak havuza görevler gönderir. Promise.all() kullanarak tüm görevlerin tamamlanmasını bekler ve ardından havuzu kapatır.

Kod Örneği (Web Workers)

Aynı kavram tarayıcıdaki Web Workers için de geçerlidir. Ancak, tarayıcı ortamı nedeniyle uygulama ayrıntıları biraz farklılık gösterir. İşte kavramsal bir özet. Yerel olarak çalışırken dosyaları bir sunucu aracılığıyla sunmazsanız (npx serve gibi bir şey kullanarak) CORS sorunları ortaya çıkabileceğini unutmayın.

// worker_pool.js (tarayıcı için)
class WorkerPool {
  constructor(numWorkers, workerFile) {
    this.numWorkers = numWorkers;
    this.workerFile = workerFile;
    this.workers = [];
    this.taskQueue = [];
    this.availableWorkers = [];

    for (let i = 0; i < numWorkers; i++) {
      const worker = new Worker(workerFile, { type: 'module' });
      const workerWrapper = {
        worker,
        isBusy: false
      };
      this.workers.push(workerWrapper);
      this.availableWorkers.push(workerWrapper);

      worker.onmessage = (event) => {
        // Görev tamamlama işlemi
        workerWrapper.isBusy = false;
        this.availableWorkers.push(workerWrapper);
        this.processTaskQueue();
      };

      worker.onerror = (error) => {
        console.error('Worker hatası:', error);
      };
    }
  }

  runTask(task) {
    return new Promise((resolve, reject) => {
      this.taskQueue.push({ task, resolve, reject });
      this.processTaskQueue();
    });
  }

  processTaskQueue() {
    if (this.taskQueue.length === 0 || this.availableWorkers.length === 0) {
      return;
    }

    const workerWrapper = this.availableWorkers.shift();
    const { task, resolve, reject } = this.taskQueue.shift();

    workerWrapper.isBusy = true;
    workerWrapper.worker.postMessage(task);

    workerWrapper.worker.onmessage = (event) => {
       resolve(event.data);
    };

    workerWrapper.worker.onerror = (error) => {
      reject(error);
    };

  }

  close() {
    this.workers.forEach(workerWrapper => workerWrapper.worker.terminate());
  }
}

export default WorkerPool;

// worker.js (tarayıcı için)
self.onmessage = (event) => {
  const task = event.data;
  // Hesaplama yoğunluğu olan bir görev simülasyonu
  const result = task * 2; // Gerçek görev mantığınızı burayla değiştirin
  self.postMessage(result);
};

// main.js (tarayıcı için, HTML'inize dahil)
import WorkerPool from './worker_pool.js';

const numWorkers = 4; // CPU sayı sayınıza göre ayarlaın
const workerFile = './worker.js';

const pool = new WorkerPool(numWorkers, workerFile);

async function main() {
  const tasks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

  const results = await Promise.all(
    tasks.map(async (task) => {
      try {
        const result = await pool.runTask(task);
        console.log(`Görev ${task} sonucu: ${result}`);
        return result;
      } catch (error) {
        console.error(`Görev ${task} başarısız oldu:`, error);
        return null;
      }
    })
  );

  console.log('Tüm görevler tamamlandı:', results);

  pool.close(); // Havuzdaki tüm worker'ları sonlandır
}

main();

Tarayıcıdaki Temel Farklılıklar:

• Web Workers, new Worker(workerFile) kullanılarak doğrudan oluşturulur.
• Mesaj işlemleri worker.onmessage ve self.onmessage (worker içinde) kullanır.
• Node.js'nin worker_threads modülündeki parentPort API'si tarayıcılarda mevcut değildir.
• Dosyalarınızın doğru MIME türleriyle sunulduğundan emin olun, özellikle JavaScript modülleri (type="module") için.

Pratik Örnekler ve Kullanım Senaryoları

Worker thread havuzunun performansı önemli ölçüde artırabileceği bazı pratik örnekleri ve kullanım senaryolarını inceleyelim.

Görüntü İşleme

Boyutlandırma, filtreleme veya format dönüştürme gibi görüntü işleme görevleri hesaplama açısından yoğun olabilir. Bu görevleri worker thread'lere boşaltmak, ana iş parçacığının duyarlı kalmasını sağlayarak, özellikle web uygulamaları için daha sorunsuz bir kullanıcı deneyimi sunar.

Örnek: Kullanıcıların görüntüleri yüklemesine ve düzenlemesine olanak tanıyan bir web uygulaması. Boyutlandırma ve filtre uygulama, görüntü işlenirken UI donmalarını önleyerek worker thread'lerde yapılabilir.

Veri Analizi

Büyük veri kümelerini analiz etmek zaman alıcı ve kaynak yoğun olabilir. Worker thread'ler veri analizi görevlerini, örneğin veri toplama, istatistiksel hesaplamalar veya makine öğrenmesi modeli eğiticiliğini paralelleştirmek için kullanılabilir.

Örnek: Finansal verileri işleyen bir veri analizi uygulaması. Hareketli ortalamalar, trend analizi ve risk değerlendirmesi gibi hesaplamalar worker thread'ler kullanılarak paralel olarak gerçekleştirilebilir.

Gerçek Zamanlı Veri Akışı

Finansal bültenler veya sensör verileri gibi gerçek zamanlı veri akışlarını işleyen uygulamalar worker thread'lerden faydalanabilir. Worker thread'ler, ana iş parçacığını engellemeden gelen veri akışlarını işlemek ve analiz etmek için kullanılabilir.

Örnek: Fiyat güncellemelerini ve grafikleri görüntüleyen gerçek zamanlı bir borsa bülteni. Veri işleme, grafik oluşturma ve uyarı bildirimleri, yüksek hacimli verilerde bile UI'nin duyarlı kalmasını sağlayarak worker thread'lerde halledilebilir.

Arka Plan Görev İşleme

Hemen kullanıcı etkileşimi gerektirmeyen herhangi bir arka plan görevi worker thread'lere boşaltılabilir. Örnekler arasında e-posta gönderme, rapor oluşturma veya zamanlanmış yedeklemeler gerçekleştirme yer alır.

Örnek: Haftalık e-posta bültenleri gönderen bir web uygulaması. E-posta gönderme işlemi worker thread'lerde halledilebilir, bu da ana iş parçacığının engellenmesini önler ve web sitesinin duyarlı kalmasını sağlar.

Birden Çok Eşzamanlı İstek İşleme (Node.js)

Node.js sunucu uygulamalarında, worker thread'ler birden çok eşzamanlı isteği paralel olarak işlemek için kullanılabilir. Bu, özellikle hesaplama açısından yoğun görevler gerçekleştiren uygulamalar için genel verimi artırabilir ve yanıt sürelerini azaltabilir.

Örnek: Kullanıcı isteklerini işleyen bir Node.js API sunucusu. Görüntü işleme, veri doğrulama ve veritabanı sorguları worker thread'lerde halledilebilir, bu da sunucunun performans düşüşü olmadan daha fazla eşzamanlı isteği işlemesini sağlar.

Worker Thread Havuzu Performansını Optimize Etme

Bir worker thread havuzunun faydalarını en üst düzeye çıkarmak için performansını optimize etmek önemlidir. İşte bazı ipuçları ve teknikler:

• Doğru Worker Sayısını Seçin: Optimal worker thread sayısı, mevcut CPU çekirdeklerinin sayısına ve iş yükünün özelliklerine bağlıdır. Genel bir kural, worker sayısını CPU çekirdek sayısına eşitleyerek başlamak ve ardından performans testlerine göre ayarlamaktır. Node.js'deki os.cpus() gibi araçlar çekirdek sayısını belirlemeye yardımcı olabilir. Thread'leri aşırı yüklemek, bağlam değiştirme ek yüküne neden olarak paralellik faydalarını ortadan kaldırabilir.
• Veri Aktarımını En Aza İndirin: Ana iş parçacığı ve worker thread'ler arasındaki veri aktarımı bir performans darboğazı olabilir. İş parçacığı içinde mümkün olduğunca fazla veriyi işleyerek aktarılması gereken veri miktarını en aza indirin. Mümkün olduğunda verileri doğrudan thread'ler arasında paylaşmak için SharedArrayBuffer'ı (uygun senkronizasyon mekanizmalarıyla) kullanmayı düşünün, ancak güvenlik sonuçlarının ve tarayıcı uyumluluğunun farkında olun.
• Görev Parçacıklarını Optimize Edin: Bireysel görevlerin boyutu ve karmaşıklığı performansı etkileyebilir. Paralelliği iyileştirmek ve uzun süren görevlerin etkisini azaltmak için büyük görevleri daha küçük, daha yönetilebilir birimlere ayırın. Ancak, görev zamanlaması ve iletişim ek yükü paralellik faydalarından daha ağır basabileceğinden, çok fazla küçük görev oluşturmaktan kaçının.
• Engelleme İşlemlerinden Kaçının: Worker thread'ler içinde engelleme işlemlerinden kaçının, çünkü bu, worker'ın diğer görevleri işlemesini engelleyebilir. Worker thread'ini duyarlı tutmak için asenkron G/Ç işlemleri ve engellemeyen algoritmalar kullanın.
• Performansı İzleyin ve Profilini Çıkarın: Darboğazları belirlemek ve worker thread havuzunu optimize etmek için performans izleme araçlarını kullanın. Node.js'nin yerleşik profilleştiricisi veya tarayıcı geliştirici araçları gibi araçlar, CPU kullanımı, bellek tüketimi ve görev yürütme süreleri hakkında bilgiler sağlayabilir.
• Hata İşleme: Worker thread'ler içinde oluşan hataları yakalamak ve işlemek için sağlam hata işleme mekanizmaları uygulayın. Yakalanmayan hatalar worker thread'ini ve potansiyel olarak tüm uygulamayı çökertirse.

Worker Thread Havuzlarına Alternatifler

Worker thread havuzları güçlü araçlar olsa da, JavaScript'te eşzamanlılık ve paralellik elde etmek için alternatif yaklaşımlar vardır.

• Promises ve Async/Await ile Asenkron Programlama: Asenkron programlama, worker thread kullanmadan engellemeyen işlemler gerçekleştirmenize olanak tanır. Promises ve async/await, asenkron kodu işlemek için daha yapılandırılmış ve okunabilir bir yol sunar. Bu, dış kaynaklar (örneğin, ağ istekleri, veritabanı sorguları) için beklediğiniz G/Ç sınırlı işlemler için uygundur.
• WebAssembly (Wasm): WebAssembly, diğer dillerde (örneğin, C++, Rust) yazılmış kodu web tarayıcılarında çalıştırmanıza olanak tanıyan bir ikili komut biçimidir. Wasm, özellikle worker thread'lerle birleştirildiğinde hesaplama açısından yoğun görevler için önemli performans iyileştirmeleri sağlayabilir. Uygulamanızın CPU yoğun bölümlerini worker thread'leri içinde çalışan Wasm modüllerine boşaltabilirsiniz.
• Service Workers: Öncelikle web uygulamalarında önbelleğe alma ve arka plan senkronizasyonu için kullanılır, Service Workers genel amaçlı arka plan işleme için de kullanılabilir. Ancak, bunlar öncelikle hesaplama açısından yoğun görevlerden ziyade ağ isteklerini ve önbelleğe almayı işlemek için tasarlanmıştır.
• Mesaj Kuyrukları (örneğin, RabbitMQ, Kafka): Dağıtılmış sistemler için, mesaj kuyrukları görevleri ayrı işlemlere veya sunuculara boşaltmak için kullanılabilir. Bu, uygulamanızı yatay olarak ölçeklendirmenize ve büyük hacimli görevleri işlemenize olanak tanır. Bu, altyapı kurulumu ve yönetimini gerektiren daha karmaşık bir çözümdür.
• Sunucusuz Fonksiyonlar (örneğin, AWS Lambda, Google Cloud Functions): Sunucusuz fonksiyonlar, sunucuları yönetmeden kodu bulutta çalıştırmanıza olanak tanır. Hesaplama açısından yoğun görevleri buluta boşaltmak ve uygulamanızı isteğe bağlı olarak ölçeklendirmek için sunucusuz fonksiyonları kullanabilirsiniz. Bu, seyrek veya önemli kaynak gerektiren görevler için iyi bir seçenektir.

Sonuç

JavaScript Modül Worker İş Parçacığı Havuzları, worker thread'leri yönetmek ve paralel yürütmeden yararlanmak için güçlü ve verimli bir mekanizma sağlar. Ek yükü azaltarak, kaynak yönetimini iyileştirerek ve görev yönetimini basitleştirerek, worker thread havuzları JavaScript uygulamalarının performansını ve yanıt verme yeteneğini önemli ölçüde artırabilir.

Bir worker thread havuzunu kullanıp kullanmayacağınıza karar verirken aşağıdaki faktörleri göz önünde bulundurun:

• Görevlerin Karmaşıklığı: Worker thread'ler, kolayca paralelleştirilebilen CPU sınırlı görevler için en faydalıdır.
• Görev Sıklığı: Görevler sık sık yürütülürse, worker thread'leri oluşturma ve yok etme ek yükü önemli olabilir. Bir iş parçacığı havuzu bunu hafifletmeye yardımcı olur.
• Kaynak Kısıtlamaları: Mevcut CPU çekirdeklerini ve belleği dikkate alın. Sisteminizi idare edebileceğinden daha fazla worker thread oluşturmayın.
• Alternatif Çözümler: Asenkron programlama, WebAssembly veya diğer eşzamanlılık tekniklerinin özel kullanım durumunuz için daha uygun olup olmayacağını değerlendirin.

Worker thread havuzlarının faydalarını ve uygulama ayrıntılarını anlayarak, geliştiriciler bunları yüksek performanslı, duyarlı ve ölçeklenebilir JavaScript uygulamaları oluşturmak için etkili bir şekilde kullanabilirler.

İstenen performans iyileştirmelerini elde ettiğinizden emin olmak için uygulamanızı worker thread'lerle ve onlarsız olarak kapsamlı bir şekilde test etmeyi ve ölçmeyi unutmayın. Optimal yapılandırma, özel iş yüküne ve donanım kaynaklarına bağlı olarak değişebilir.

SharedArrayBuffer ve Atomics (senkronizasyon için) gibi gelişmiş teknikler üzerine daha fazla araştırma yapmak, worker thread'leri kullanırken performans optimizasyonu için daha da fazla potansiyel kilidini açabilir.