1
ALGORITHM Producer
2
  WHILE system is running DO
3
    data ← generateNewData()
4
    IF buffer has space THEN
5
      add data to buffer
6
    ELSE
7
      wait until space becomes available
8
    END IF
9
  END WHILE
10
END ALGORITHM

1
ALGORITHM Consumer
2
  WHILE system is running DO
3
    IF buffer has data THEN
4
      data ← get data from buffer
5
      process(data)
6
    ELSE
7
      wait until data becomes available
8
    END IF
9
  END WHILE
10
END ALGORITHM

1
// Senkron örnek
2
PROCEDURE SynchronousExample
3
  result1 ← performSlowOperation1()  // 5 saniye bekler
4
  result2 ← performSlowOperation2()  // 3 saniye bekler
5
  return combine(result1, result2)   // Toplam 8 saniye alır
6
END PROCEDURE

1
// Asenkron örnek
2
PROCEDURE AsynchronousExample
3
  promise1 ← startSlowOperation1()  // Hemen döner, işlem arka planda
4
  promise2 ← startSlowOperation2()  // Hemen döner, işlem arka planda
5

6
  // Diğer işler yapılabilir
7
  doOtherWork()
8

9
  // Sonuçları topla
10
  result1 ← await promise1
11
  result2 ← await promise2
12
  return combine(result1, result2)  // Toplam ~5 saniye alır
13
END PROCEDURE

1
// Single-thread örnek
2
PROCEDURE SingleThreadExample
3
  FOR i = 1 TO 1000000 DO
4
    processItem(i)
5
  END FOR
6
  // 4 çekirdekli sistemde sadece 1 çekirdek kullanılır
7
END PROCEDURE

1
// Multi-thread örnek
2
PROCEDURE MultiThreadExample
3
  CREATE 4 worker threads
4
  THREAD Worker1: process items 1-250000
5
  THREAD Worker2: process items 250001-500000
6
  THREAD Worker3: process items 500001-750000
7
  THREAD Worker4: process items 750001-1000000
8
  WAIT for all threads to complete
9
  // 4 çekirdekli sistemde 4 çekirdek paralel kullanılır
10
END PROCEDURE

1
// Senkron yaklaşım (Kötü)
2
PROCEDURE ProcessFilesSynchronous
3
  FOR each file IN fileList DO
4
    content ← readFile(file)         // 50ms I/O wait
5
    result ← processContent(content) // 5ms CPU work
6
    saveResult(result)               // 20ms I/O wait
7
  END FOR
8
  // Total: 1000 × 75ms = 75 saniye
9
END PROCEDURE

1
// Asenkron + Single Thread (İyi I/O için)
2
PROCEDURE ProcessFilesAsync
3
  promises ← []
4
  FOR each file IN fileList DO
5
    promise ← startAsyncFileProcessing(file)  // Non-blocking
6
    promises.add(promise)
7
  END FOR
8
  results ← awaitAll(promises)
9
  // Total: ~75ms (tüm I/O operations paralel)
10
END PROCEDURE

1
// Multi-Thread (I/O için gereksiz karmaşık)
2
PROCEDURE ProcessFilesMultiThread
3
  CREATE threadPool with 10 threads
4
  workQueue ← create queue
5
  FOR each file IN fileList DO
6
    workQueue.enqueue(file)
7
  END FOR
8
  FOR each thread IN threadPool DO
9
    WHILE workQueue has items DO
10
      file ← workQueue.dequeue()
11
      processFile(file)  // Her thread senkron çalışır
12
    END WHILE
13
  END FOR
14
  // Total: ~7.5 saniye + thread overhead
15
END PROCEDURE

1
// Asenkron (CPU bound için etkisiz)
2
PROCEDURE ComputeSumAsync
3
  // Tek CPU core, matematiksel hesaplama
4
  // Asenkron I/O yok, sadece CPU hesaplama
5
  sum ← 0
6
  FOR i = 1 TO 1000000 DO
7
    sum ← sum + (i × i)  // Pure CPU work
8
  END FOR
9
  // Asenkron'un faydası yok, tek thread kullanılır
10
END PROCEDURE

1
// Multi-Thread (CPU bound için mükemmel)
2
PROCEDURE ComputeSumMultiThread
3
  CREATE 4 worker threads
4
  partialSums ← array[4]
5
  THREAD 1: compute sum for 1-250000
6
  THREAD 2: compute sum for 250001-500000
7
  THREAD 3: compute sum for 500001-750000
8
  THREAD 4: compute sum for 750001-1000000
9
  totalSum ← partialSums[1] + ... + partialSums[4]
10
  // 4 çekirdekli sistemde ~4x hızlanma
11
END PROCEDURE

1
// Web server örneği
2
PROCEDURE HybridWebServer
3
  // Multi-threading: Paralel request handling
4
  CREATE thread pool with 16 worker threads
5
  FOR each worker thread DO
6
    WHILE server is running DO
7
      request ← acceptIncomingRequest()
8

9
      // Asenkron: I/O operations non-blocking
10
      userDataPromise ← fetchUserDataAsync(request.userId)
11
      productDataPromise ← fetchProductDataAsync(request.productId)
12

13
      // CPU bound work while I/O continues
14
      validationResult ← validateRequest(request)
15

16
      // Await I/O results
17
      userData ← await userDataPromise
18
      productData ← await productDataPromise
19

20
      response ← buildResponse(userData, productData, validationResult)
21
      sendResponse(response)
22
    END WHILE
23
  END FOR
24
END PROCEDURE

1
// Tüketici-üretici: Asenkron + Multi-thread hybrid
2
PROCEDURE ProducerConsumerHybrid
3
  buffer ← createThreadSafeQueue()
4

5
  // Multi-thread: Paralel üreticiler
6
  FOR i = 1 TO 4 DO
7
    CREATE producer thread:
8
      WHILE active DO
9
        data ← generateData()
10
        buffer.enqueue(data)  // Asenkron: non-blocking enqueue
11
      END WHILE
12
  END FOR
13

14
  // Multi-thread: Paralel tüketiciler
15
  FOR i = 1 TO 8 DO
16
    CREATE consumer thread:
17
      WHILE active DO
18
        data ← buffer.dequeue()  // Asenkron: non-blocking dequeue
19
        processData(data)
20
      END WHILE
21
  END FOR
22
END PROCEDURE

1
NEW → READY → RUNNING → BLOCKED → READY → RUNNING → TERMINATED
2
       ↑        ↑         ↓         ↑         ↑
3
   Scheduler   CPU      I/O Start  I/O End  Context
4
    assigns   active   (PASSIVE)  Complete  Switch

1
PROCEDURE SynchronousProcessing
2
  WHILE hasData DO
3
    data ← readFromDisk()        // 10ms I/O wait (PASIF BEKLEME)
4
    result ← processData(data)   // 2ms CPU work (AKTİF)
5
    writeToDatabase(result)      // 15ms I/O wait (PASIF BEKLEME)
6
  END WHILE
7
  // Total: 2ms CPU / 27ms total = %7.4 CPU utilization
8
END PROCEDURE

1
REPEAT FOREVER:
2
  1. FETCH: Memory'den instruction'ı getir
3
  2. DECODE: Instruction'ı çözümle (ne yapacağını anla)
4
  3. EXECUTE: Instruction'ı gerçekleştir
5
  4. WRITE-BACK: Sonucu register/memory'ye yaz
6
END REPEAT

1
// Üretici Thread (I/O yoğun)
2
PROCEDURE ProducerThread
3
  WHILE active DO
4
    data ← readFromDisk()     // 10ms I/O
5
    buffer.enqueue(data)      // 0.1ms CPU
6
    // Tüketicinin bu veriyi ne zaman işleyeceğini beklemez
7
  END WHILE
8
END PROCEDURE

1
// Tüketici Thread (CPU yoğun)
2
PROCEDURE ConsumerThread
3
  WHILE active DO
4
    data ← buffer.dequeue()       // 0.1ms CPU
5
    result ← processData(data)    // 2ms CPU
6
    writeBuffer.enqueue(result)   // 0.1ms CPU
7
    // Üreticinin yeni veri üretmesini beklemez
8
  END WHILE
9
END PROCEDURE

1
// Writer Thread (I/O yoğun)
2
PROCEDURE WriterThread
3
  WHILE active DO
4
    result ← writeBuffer.dequeue()  // 0.1ms CPU
5
    writeToDatabase(result)         // 15ms I/O
6
    // Tüketicinin yeni sonuç üretmesini beklemez
7
  END WHILE
8
END PROCEDURE

1
Senkron Model:
2
T1: [READ]-[PROCESS]-[WRITE] (27ms total)
3
T2:                          [READ]-[PROCESS]-[WRITE] (27ms)
4
T3:                                                   [READ]-[PROCESS]-[WRITE]
5

6
Pipelined Model:
7
T1: [READ]
8
T2:        [PROCESS] [READ]
9
T3:                  [WRITE] [PROCESS] [READ]
10
T4:                          [WRITE]   [PROCESS]
11
T5:                                    [WRITE]
12

13
3 operation için:
14
Senkron: 81ms
15
Pipelined: 31ms (%62 faster)

1
Buffer Size = Producer Rate × Consumer Processing Time × Safety Factor
2
Örnek: 10MB/s × 0.1s × 2 = 2MB optimal tampon boyutu

1
// Teorik minimum:
2
Producer Rate: 1000 mesaj/saniye
3
Consumer Processing: 10ms/mesaj
4
Minimum Buffer = 1000 × 0.01 = 10 mesaj
5

6
// Gerçek dünyada olabilecekler:
7
- Traffic'te %300 artış
8
- Database yavaşlaması → 10ms'den 50ms'ye
9
- GC duraklamaları → 100ms kesintiler
10

11
// Safety Factor ile:
12
Safety Factor = 3
13
Actual Buffer = 10 × 3 = 30 mesaj

1
PROCEDURE HandleHttpRequest
2
  request ← ReceiveHttpRequest()
3
  processedData ← ProcessRequest(request)
4
  WriteLogToDisk(processedData)  // I/O bound, slow operation
5
  SendHttpResponse(processedData)
6
END PROCEDURE

1
GLOBAL logQueue ← CREATE thread-safe queue
2

3
PROCEDURE HandleHttpRequest
4
  request ← ReceiveHttpRequest()
5
  processedData ← ProcessRequest(request)
6
  // Log mesajını kuyruğa ekler ve hemen devam eder
7
  logQueue.Enqueue(CreateLogMessage(processedData))
8
  // Yanıtı hemen döndürür
9
  SendHttpResponse(processedData)
10
END PROCEDURE
11

12
PROCEDURE LoggerThread
13
  WHILE serverIsRunning DO
14
    IF logQueue is not empty THEN
15
      logMessage ← logQueue.Dequeue()
16
      WriteLogToDisk(logMessage)  // I/O bound, slow operation
17
    ELSE
18
      Sleep(small_amount)  // Kuyruk boşsa kısa bir süre bekle
19
    END IF
20
  END WHILE
21
END PROCEDURE

1
PROCEDURE MultiConsumerSetup
2
  sharedBuffer ← createThreadSafeQueue()
3
  consumers ← []
4

5
  // 8 consumer thread oluştur
6
  FOR i = 1 TO 8 DO
7
    consumer ← CREATE consumer thread:
8
      WHILE active DO
9
        IF sharedBuffer.hasData() THEN
10
          data ← sharedBuffer.dequeue()
11
          processData(data)
12
        ELSE
13
          // Work stealing: başka consumer'ın işini çal
14
          data ← stealWorkFromOtherConsumer()
15
          IF data is not null THEN
16
            processData(data)
17
          END IF
18
        END IF
19
      END WHILE
20
    consumers.add(consumer)
21
  END FOR
22
END PROCEDURE

1
STRUCTURE LockFreeQueue
2
  head ← ALIGNED(64) atomic_pointer
3
  tail ← ALIGNED(64) atomic_pointer
4

5
  PROCEDURE enqueue(item)
6
    newNode ← allocateNode(item)
7
    REPEAT
8
      currentTail ← tail.load()
9
      nextNode ← currentTail.next.load()
10
      IF currentTail = tail.load() THEN  // Consistency check
11
        IF nextNode is null THEN
12
          // Try to link new node
13
          IF currentTail.next.compareAndSwap(null, newNode) THEN
14
            break  // Success
15
          END IF
16
        ELSE
17
          // Help advance tail
18
          tail.compareAndSwap(currentTail, nextNode)
19
        END IF
20
      END IF
21
    UNTIL successful
22
    // Advance tail
23
    tail.compareAndSwap(currentTail, newNode)
24
  END PROCEDURE
25

26
  PROCEDURE dequeue()
27
    REPEAT
28
      currentHead ← head.load()
29
      currentTail ← tail.load()
30
      nextNode ← currentHead.next.load()
31
      IF currentHead = head.load() THEN  // Consistency check
32
        IF currentHead = currentTail THEN
33
          IF nextNode is null THEN
34
            return null  // Queue is empty
35
          END IF
36
          // Help advance tail
37
          tail.compareAndSwap(currentTail, nextNode)
38
        ELSE
39
          IF nextNode is null THEN
40
            continue  // Inconsistent state
41
          END IF
42
          data ← nextNode.data
43
          IF head.compareAndSwap(currentHead, nextNode) THEN
44
            return data  // Success
45
          END IF
46
        END IF
47
      END IF
48
    UNTIL successful
49
  END PROCEDURE
50
END STRUCTURE

1
FUNCTION calculateOptimalBufferSize(producerRate, consumerTime, safetyFactor)
2
  RETURN producerRate × consumerTime × safetyFactor
3
END FUNCTION
4

5
// Örnek hesaplama:
6
// Producer: 100K msg/sec
7
// Consumer: 10μs/msg işleme süresi
8
// Safety factor: 2
9
// Optimal size: 100,000 × 0.00001 × 2 = 2,000 mesaj

1
STRUCTURE RingBuffer
2
  data ← ALIGNED(64) array[SIZE]
3
  writeIndex ← ALIGNED(64) atomic_int
4
  readIndex ← ALIGNED(64) atomic_int
5
  PADDING to prevent false sharing
6

7
  PROCEDURE enqueue(item)
8
    currentWrite ← writeIndex.load()
9
    nextWrite ← (currentWrite + 1) % SIZE
10
    // Check if buffer is full
11
    IF nextWrite = readIndex.load() THEN
12
      return false  // Buffer full
13
    END IF
14
    data[currentWrite] ← item
15
    writeIndex.store(nextWrite)
16
    return true
17
  END PROCEDURE
18

19
  PROCEDURE dequeue()
20
    currentRead ← readIndex.load()
21
    // Check if buffer is empty
22
    IF currentRead = writeIndex.load() THEN
23
      return null  // Buffer empty
24
    END IF
25
    item ← data[currentRead]
26
    readIndex.store((currentRead + 1) % SIZE)
27
    return item
28
  END PROCEDURE
29
END STRUCTURE

1
STRUCTURE AdaptiveBackpressure
2
  bufferUtilization ← 0.0
3
  throttleRate ← 0.0
4

5
  PROCEDURE updateBackpressure(currentBufferSize, maxBufferSize)
6
    bufferUtilization ← currentBufferSize / maxBufferSize
7
    IF bufferUtilization > 0.8 THEN
8
      throttleRate ← (bufferUtilization - 0.8) × 5.0
9
    ELSE IF bufferUtilization < 0.6 THEN
10
      throttleRate ← max(0, throttleRate - 0.1)
11
    END IF
12
  END PROCEDURE
13

14
  PROCEDURE shouldThrottleProducer()
15
    IF throttleRate > 0 THEN
16
      sleepTime ← throttleRate × BASE_SLEEP_TIME
17
      sleep(sleepTime)
18
    END IF
19
  END PROCEDURE
20
END STRUCTURE

1
STRUCTURE OptimizedThreadPool
2
  taskQueue ← CREATE lock-free queue
3
  workerCount ← CPU_CORES × 2
4
  workers ← array[workerCount]
5

6
  PROCEDURE submitTask(task)
7
    IF queue.size() > THRESHOLD THEN
8
      applyBackpressure()
9
    END IF
10
    queue.enqueue(task)  // O(1) complexity
11
  END PROCEDURE
12

13
  PROCEDURE workerThread(workerId)
14
    WHILE active DO
15
      task ← queue.dequeue()  // O(1) amortized
16
      IF task IS NULL THEN
17
        waitStrategy.idle()  // Exponential backoff
18
      ELSE
19
        executeTask(task)
20
        updateWorkerMetrics(workerId)
21
      END IF
22
    END WHILE
23
  END PROCEDURE
24

25
  PROCEDURE initialize()
26
    FOR i = 1 TO workerCount DO
27
      workers[i] ← CREATE thread executing workerThread(i)
28
      pinThreadToCore(workers[i], i % CPU_CORES)
29
    END FOR
30
  END PROCEDURE
31
END STRUCTURE

1
STRUCTURE HighPerformanceLogger
2
  ringBuffer ← CREATE ring buffer(65536)
3
  loggerThread ← null
4
  batchSize ← 1000
5

6
  PROCEDURE logMessage(level, message)
7
    entry ← createLogEntry(level, message, currentTime())
8
    ringBuffer.enqueue(entry)  // Wait-free operation
9
  END PROCEDURE
10

11
  PROCEDURE loggerWorkerThread()
12
    batch ← array[batchSize]
13
    WHILE system is running DO
14
      batchCount ← 0
15
      // Collect batch
16
      WHILE batchCount < batchSize AND ringBuffer.hasData() DO
17
        batch[batchCount] ← ringBuffer.dequeue()
18
        batchCount ← batchCount + 1
19
      END WHILE
20
      // Write batch to disk (single I/O operation)
21
      IF batchCount > 0 THEN
22
        writeBatchToDisk(batch, batchCount)
23
      END IF
24
      // Yield if no work
25
      IF batchCount = 0 THEN
26
        yield()
27
      END IF
28
    END WHILE
29
  END PROCEDURE
30
END STRUCTURE

1
STRUCTURE DataProcessingPipeline
2
  stage1Queue ← CREATE bounded queue(1000)
3
  stage2Queue ← CREATE bounded queue(1000)
4
  outputQueue ← CREATE bounded queue(1000)
5

6
  PROCEDURE Stage1_Reader(inputFiles)
7
    FOR each file IN inputFiles DO
8
      rawData ← readFile(file)
9
      stage1Queue.enqueue(rawData)
10
    END FOR
11
  END PROCEDURE
12

13
  PROCEDURE Stage2_Transformer()
14
    WHILE system is running DO
15
      rawData ← stage1Queue.dequeue()
16
      IF rawData is not null THEN
17
        transformedData ← transform(rawData)
18
        stage2Queue.enqueue(transformedData)
19
      END IF
20
    END WHILE
21
  END PROCEDURE
22

23
  PROCEDURE Stage3_Analyzer()
24
    WHILE system is running DO
25
      data ← stage2Queue.dequeue()
26
      IF data is not null THEN
27
        results ← analyze(data)
28
        outputQueue.enqueue(results)
29
      END IF
30
    END WHILE
31
  END PROCEDURE
32
END STRUCTURE

1
PROCEDURE OrderService_Producer
2
  WHEN new order is received
3
    orderDetails ← prepareOrderData()
4
    messageQueue.send("orderQueue", orderDetails)
5
  END WHEN
6
END PROCEDURE
7

8
PROCEDURE PaymentService_Consumer
9
  REPEAT
10
    order ← messageQueue.receive("orderQueue")
11
    processPayment(order)
12
  FOREVER
13
END PROCEDURE
14

15
PROCEDURE InventoryService_Consumer
16
  REPEAT
17
    order ← messageQueue.receive("orderQueue")
18
    updateInventory(order)
19
  FOREVER
20
END PROCEDURE

1
FUNCTION calculateBufferSize(
2
  producerRate,   // msgs/sec
3
  consumerRate,   // msgs/sec
4
  burstFactor,    // Peak/average ratio
5
  latencyTarget   // ms
6
)
7
  // Base capacity for steady state
8
  baseCapacity ← (producerRate / consumerRate) × latencyTarget / 1000
9
  // Additional capacity for bursts
10
  burstCapacity ← baseCapacity × burstFactor
11
  // Safety margin
12
  safetyMargin ← burstCapacity × 0.5
13
  RETURN baseCapacity + burstCapacity + safetyMargin
14
END FUNCTION

1
// I/O Bound threads (Producers/Writers)
2
ioThreadCount ← CPU_CORES × 0.25
3

4
// CPU Bound threads (Consumers)
5
cpuThreadCount ← CPU_CORES × 1.0
6

7
// Total optimal threads
8
totalThreads ← CPU_CORES × 1.5
9

10
// Thread affinity
11
FOR each thread DO
12
  pinThreadToCore(thread, thread.id % CPU_CORES)
13
END FOR

1
STRUCTURE SystemMetrics
2
  // Buffer health
3
  bufferUtilization ← currentSize / maxSize
4
  bufferDepthHistogram ← histogram of buffer sizes
5

6
  // Throughput metrics
7
  producerRate ← messages produced per second
8
  consumerRate ← messages consumed per second
9
  endToEndLatency ← time from produce to consume
10

11
  // Resource utilization
12
  cpuUtilization ← per-core CPU usage
13
  memoryUsage ← heap and off-heap memory
14
  gcPauseTime ← garbage collection impact
15

16
  // Error rates
17
  bufferOverflowRate ← dropped messages per second
18
  consumerErrorRate ← processing failures per second
19
  backpressureEvents ← throttling occurrences
20
END STRUCTURE

1
PROCEDURE checkAlerts(metrics)
2
  // Buffer health alerts
3
  IF metrics.bufferUtilization > 0.8 THEN
4
    alert("High buffer utilization", WARN)
5
  END IF
6
  IF metrics.bufferUtilization > 0.95 THEN
7
    alert("Critical buffer utilization", CRITICAL)
8
  END IF
9

10
  // Performance alerts
11
  IF metrics.endToEndLatency > SLA_LATENCY × 2 THEN
12
    alert("High latency detected", WARN)
13
  END IF
14

15
  // Error rate alerts
16
  IF metrics.consumerErrorRate > 0.01 THEN  // 1% error rate
17
    alert("High consumer error rate", CRITICAL)
18
  END IF
19
END PROCEDURE

1
STRUCTURE CacheOptimizedBuffer
2
  // Each field on separate cache line (64 bytes)
3
  producerIndex ← ALIGNED(64) atomic_int
4
  PADDING[60] bytes
5
  consumerIndex ← ALIGNED(64) atomic_int
6
  PADDING[60] bytes
7
  data ← ALIGNED(64) array[SIZE]
8
END STRUCTURE

1
PROCEDURE initializeNumaOptimized()
2
  numaNodes ← getNumaTopology()
3
  FOR each node IN numaNodes DO
4
    // Allocate buffer memory on local node
5
    buffer[node] ← allocateLocalMemory(node, BUFFER_SIZE)
6
    // Pin threads to local cores
7
    producersForNode ← createProducers(node.coreCount / 4)
8
    consumersForNode ← createConsumers(node.coreCount / 2)
9
    FOR each thread IN (producersForNode + consumersForNode) DO
10
      pinThreadToNode(thread, node.id)
11
    END FOR
12
  END FOR
13
END PROCEDURE

1
PROCEDURE lockFreeIncrement(counter)
2
  REPEAT
3
    currentValue ← counter.load()
4
    newValue ← currentValue + 1
5
  UNTIL counter.compareAndSwap(currentValue, newValue)
6
END PROCEDURE

1
// Relaxed memory ordering (fastest)
2
counter.store(value, memory_order_relaxed)
3

4
// Acquire-release semantics (safe for most cases)
5
counter.store(value, memory_order_release)
6
data ← counter.load(memory_order_acquire)
7

8
// Sequential consistency (safest, slowest)
9
counter.store(value, memory_order_seq_cst)

1
Application → Kernel → Network Stack → Hardware → Network
2
Latency: ~50μs, CPU overhead: High

1
Application → Hardware → Network (bypass kernel)
2
Latency: ~1μs, CPU overhead: Minimal

1
PROCEDURE dpdkOptimizedReceiver()
2
  // Initialize DPDK
3
  dpdkPort ← initializeDPDKPort()
4
  hugepages ← allocateHugePages(1GB)
5

6
  WHILE active DO
7
    // Batch receive (no system calls)
8
    packets ← dpdkPort.receiveBatch(32)
9
    FOR each packet IN packets DO
10
      data ← extractData(packet)
11
      buffer.enqueue(data)  // Lock-free enqueue
12
    END FOR
13
  END WHILE
14
END PROCEDURE