仮想メモリアドレス変換の実装例

// 仮想メモリアドレス変換のシミュレーション
class VirtualMemoryManager {
    constructor(pageSize = 4096, physicalPages = 1024) {
        this.pageSize = pageSize;
        this.physicalPages = physicalPages;
        this.pageTable = new Map(); // 論理→物理アドレス変換表
        this.tlb = new Map(); // Translation Lookaside Buffer
        this.freePages = Array.from({length: physicalPages}, (_, i) => i);
        this.pageFaultCount = 0;
        this.tlbHitCount = 0;
        this.tlbMissCount = 0;
    }
    
    // 論理アドレスを物理アドレスに変換
    translateAddress(virtualAddress) {
        const pageNumber = Math.floor(virtualAddress / this.pageSize);
        const offset = virtualAddress % this.pageSize;
        
        // TLBを先にチェック（高速化）
        if (this.tlb.has(pageNumber)) {
            this.tlbHitCount++;
            const physicalPage = this.tlb.get(pageNumber);
            return physicalPage * this.pageSize + offset;
        }
        
        this.tlbMissCount++;
        
        // ページテーブルをチェック
        if (!this.pageTable.has(pageNumber)) {
            // ページフォルト発生
            this.handlePageFault(pageNumber);
        }
        
        const physicalPage = this.pageTable.get(pageNumber);
        
        // TLBに追加（キャッシュ）
        if (this.tlb.size >= 64) { // TLBサイズ制限
            const firstKey = this.tlb.keys().next().value;
            this.tlb.delete(firstKey);
        }
        this.tlb.set(pageNumber, physicalPage);
        
        return physicalPage * this.pageSize + offset;
    }
    
    // ページフォルト処理
    handlePageFault(pageNumber) {
        this.pageFaultCount++;
        
        if (this.freePages.length === 0) {
            // ページ置換が必要
            this.evictPage();
        }
        
        const physicalPage = this.freePages.pop();
        this.pageTable.set(pageNumber, physicalPage);
        
        console.log(`Page fault: Loading page ${pageNumber} to frame ${physicalPage}`);
    }
    
    // ページ置換（簡単なFIFO実装）
    evictPage() {
        const [oldestPage] = this.pageTable.entries().next().value;
        const freedFrame = this.pageTable.get(oldestPage);
        
        this.pageTable.delete(oldestPage);
        this.tlb.delete(oldestPage);
        this.freePages.push(freedFrame);
        
        console.log(`Evicted page ${oldestPage} from frame ${freedFrame}`);
    }
    
    // 統計情報表示
    getStatistics() {
        const totalAccesses = this.tlbHitCount + this.tlbMissCount;
        const tlbHitRate = totalAccesses > 0 ? (this.tlbHitCount / totalAccesses * 100).toFixed(2) : 0;
        
        return {
            pageFaults: this.pageFaultCount,
            tlbHitRate: `${tlbHitRate}%`,
            tlbHits: this.tlbHitCount,
            tlbMisses: this.tlbMissCount,
            allocatedPages: this.pageTable.size
        };
    }
}

// 使用例
const vmm = new VirtualMemoryManager();

// アドレス変換のテスト
const addresses = [0x1000, 0x2000, 0x1040, 0x3000, 0x1080];
addresses.forEach(addr => {
    const physical = vmm.translateAddress(addr);
    console.log(`Virtual: 0x${addr.toString(16)} → Physical: 0x${physical.toString(16)}`);
});

console.log('Statistics:', vmm.getStatistics());

共有メモリとセマフォの実装例

// プロセス間通信のシミュレーション
class SharedMemorySegment {
    constructor(size) {
        this.buffer = new ArrayBuffer(size);
        this.view = new DataView(this.buffer);
        this.size = size;
        this.writeIndex = 0;
        this.readIndex = 0;
    }
    
    write(data) {
        if (this.writeIndex + data.length <= this.size) {
            const bytes = new Uint8Array(data);
            for (let i = 0; i < bytes.length; i++) {
                this.view.setUint8(this.writeIndex + i, bytes[i]);
            }
            this.writeIndex += bytes.length;
            return true;
        }
        return false; // バッファフル
    }
    
    read(length) {
        if (this.readIndex + length <= this.writeIndex) {
            const result = new Uint8Array(length);
            for (let i = 0; i < length; i++) {
                result[i] = this.view.getUint8(this.readIndex + i);
            }
            this.readIndex += length;
            return result;
        }
        return null; // データ不足
    }
}

// セマフォ（排他制御）
class Semaphore {
    constructor(initial = 1) {
        this.count = initial;
        this.waitQueue = [];
    }
    
    async acquire() {
        return new Promise((resolve) => {
            if (this.count > 0) {
                this.count--;
                resolve();
            } else {
                this.waitQueue.push(resolve);
            }
        });
    }
    
    release() {
        if (this.waitQueue.length > 0) {
            const resolve = this.waitQueue.shift();
            resolve();
        } else {
            this.count++;
        }
    }
}

// プロデューサー・コンシューマー問題の解決例
class ProducerConsumerExample {
    constructor() {
        this.sharedMemory = new SharedMemorySegment(1024);
        this.mutex = new Semaphore(1); // 排他制御
        this.empty = new Semaphore(10); // 空きスロット数
        this.full = new Semaphore(0);  // データ数
        this.items = [];
    }
    
    async producer(data) {
        await this.empty.acquire();  // 空きを待つ
        await this.mutex.acquire();  // 排他開始
        
        // クリティカルセクション
        this.items.push(data);
        console.log(`Produced: ${data}`);
        
        this.mutex.release();        // 排他終了
        this.full.release();         // データ追加を通知
    }
    
    async consumer() {
        await this.full.acquire();   // データを待つ
        await this.mutex.acquire();  // 排他開始
        
        // クリティカルセクション
        const item = this.items.shift();
        console.log(`Consumed: ${item}`);
        
        this.mutex.release();        // 排他終了
        this.empty.release();        // 空きを通知
        
        return item;
    }
}

// 使用例
const pc = new ProducerConsumerExample();

// プロデューサー
for (let i = 0; i < 5; i++) {
    pc.producer(`Item-${i}`);
}

// コンシューマー
setTimeout(async () => {
    for (let i = 0; i < 3; i++) {
        await pc.consumer();
    }
}, 100);

割り込み処理システムのシミュレーション

// 割り込みシステムの実装例
class InterruptController {
    constructor() {
        this.interruptTable = new Map(); // 割り込みベクタテーブル
        this.priorityLevels = 8; // 優先度レベル数
        this.interruptMask = 0; // 割り込みマスク
        this.pendingInterrupts = new Set(); // 待機中の割り込み
        this.currentPriority = 0; // 現在の実行優先度
        this.cpuContext = null; // CPU状態保存
    }
    
    // 割り込みハンドラの登録
    registerHandler(interruptType, priority, handler) {
        this.interruptTable.set(interruptType, {
            priority: priority,
            handler: handler,
            enabled: true
        });
    }
    
    // 割り込み要求の発生
    requestInterrupt(interruptType) {
        const interrupt = this.interruptTable.get(interruptType);
        if (!interrupt || !interrupt.enabled) {
            return false;
        }
        
        // 割り込みマスクチェック
        if (this.interruptMask & (1 << interrupt.priority)) {
            return false;
        }
        
        // 現在より低い優先度は無視
        if (interrupt.priority <= this.currentPriority) {
            this.pendingInterrupts.add(interruptType);
            return false;
        }
        
        this.handleInterrupt(interruptType);
        return true;
    }
    
    // 割り込み処理の実行
    handleInterrupt(interruptType) {
        const interrupt = this.interruptTable.get(interruptType);
        
        console.log(`Interrupt ${interruptType} (priority ${interrupt.priority}) triggered`);
        
        // CPU状態保存
        this.saveContext();
        
        // 優先度更新
        const oldPriority = this.currentPriority;
        this.currentPriority = interrupt.priority;
        
        try {
            // 割り込みハンドラ実行
            interrupt.handler(interruptType);
        } catch (error) {
            console.error(`Interrupt handler error:`, error);
        }
        
        // 状態復元
        this.currentPriority = oldPriority;
        this.restoreContext();
        
        // 待機中の割り込みをチェック
        this.checkPendingInterrupts();
    }
    
    // CPU状態の保存
    saveContext() {
        this.cpuContext = {
            registers: {
                ax: Math.floor(Math.random() * 65536),
                bx: Math.floor(Math.random() * 65536),
                cx: Math.floor(Math.random() * 65536),
                dx: Math.floor(Math.random() * 65536)
            },
            programCounter: Math.floor(Math.random() * 1048576),
            statusFlags: Math.floor(Math.random() * 256)
        };
        console.log('CPU context saved:', this.cpuContext);
    }
    
    // CPU状態の復元
    restoreContext() {
        if (this.cpuContext) {
            console.log('CPU context restored:', this.cpuContext);
            this.cpuContext = null;
        }
    }
    
    // 待機中割り込みの処理
    checkPendingInterrupts() {
        const sortedPending = Array.from(this.pendingInterrupts)
            .map(type => ({
                type,
                priority: this.interruptTable.get(type).priority
            }))
            .sort((a, b) => b.priority - a.priority);
            
        for (const pending of sortedPending) {
            if (pending.priority > this.currentPriority) {
                this.pendingInterrupts.delete(pending.type);
                this.handleInterrupt(pending.type);
                break;
            }
        }
    }
    
    // 割り込みマスクの設定
    setInterruptMask(mask) {
        this.interruptMask = mask;
        console.log(`Interrupt mask set to: 0b${mask.toString(2).padStart(8, '0')}`);
    }
}

// 使用例
const ic = new InterruptController();

// 各種割り込みハンドラの登録
ic.registerHandler('TIMER', 7, (type) => {
    console.log(`Timer interrupt handled - system tick`);
});

ic.registerHandler('KEYBOARD', 5, (type) => {
    console.log(`Keyboard interrupt handled - key pressed`);
});

ic.registerHandler('DISK', 3, (type) => {
    console.log(`Disk interrupt handled - I/O complete`);
});

ic.registerHandler('NETWORK', 4, (type) => {
    console.log(`Network interrupt handled - packet received`);
});

// 割り込みシミュレーション
console.log('=== Interrupt Simulation ===');
ic.requestInterrupt('KEYBOARD');
ic.requestInterrupt('TIMER');
ic.requestInterrupt('DISK');
ic.requestInterrupt('NETWORK');

DMAシステムのシミュレーション

// DMAコントローラのシミュレーション
class DMAController {
    constructor() {
        this.channels = Array(8).fill(null).map((_, i) => ({
            id: i,
            busy: false,
            sourceAddress: 0,
            destinationAddress: 0,
            transferCount: 0,
            direction: 'read', // 'read', 'write', 'memory-to-memory'
            priority: 0,
            callback: null
        }));
        this.memory = new ArrayBuffer(1024 * 1024); // 1MB メモリ
        this.memoryView = new DataView(this.memory);
        this.transferQueue = [];
    }
    
    // DMA転送要求
    requestTransfer(config) {
        const availableChannel = this.channels.find(ch => !ch.busy);
        
        if (!availableChannel) {
            // 全チャネルがビジー：キューに追加
            this.transferQueue.push(config);
            return null;
        }
        
        return this.setupTransfer(availableChannel, config);
    }
    
    // DMA転送の設定
    setupTransfer(channel, config) {
        Object.assign(channel, {
            busy: true,
            sourceAddress: config.source,
            destinationAddress: config.destination,
            transferCount: config.count,
            direction: config.direction,
            priority: config.priority || 0,
            callback: config.callback
        });
        
        console.log(`DMA Channel ${channel.id} setup:`, {
            source: `0x${config.source.toString(16)}`,
            destination: `0x${config.destination.toString(16)}`,
            count: config.count,
            direction: config.direction
        });
        
        // 非同期でDMA転送を実行
        this.executeTransfer(channel);
        
        return channel.id;
    }
    
    // DMA転送の実行（シミュレーション）
    async executeTransfer(channel) {
        const transferTime = channel.transferCount * 0.001; // 転送時間シミュレーション
        
        console.log(`DMA Channel ${channel.id} starting transfer...`);
        
        // 転送シミュレーション（実際のハードウェアでは並列実行）
        await new Promise(resolve => setTimeout(resolve, transferTime));
        
        // データ転送の実行（簡略化）
        if (channel.direction === 'memory-to-memory') {
            for (let i = 0; i < channel.transferCount; i++) {
                const data = this.memoryView.getUint8(channel.sourceAddress + i);
                this.memoryView.setUint8(channel.destinationAddress + i, data);
            }
        }
        
        console.log(`DMA Channel ${channel.id} transfer complete`);
        
        // 転送完了処理
        this.completeTransfer(channel);
    }
    
    // 転送完了処理
    completeTransfer(channel) {
        // コールバック実行（割り込みハンドラのシミュレーション）
        if (channel.callback) {
            channel.callback(channel.id, 'success');
        }
        
        // チャネル解放
        channel.busy = false;
        
        // キューの次の転送を開始
        if (this.transferQueue.length > 0) {
            const nextTransfer = this.transferQueue.shift();
            this.requestTransfer(nextTransfer);
        }
        
        // システムに転送完了を通知（割り込み）
        this.notifyTransferComplete(channel.id);
    }
    
    // 転送完了割り込み
    notifyTransferComplete(channelId) {
        console.log(`DMA interrupt: Channel ${channelId} transfer completed`);
        
        // 実際のシステムでは、ここで割り込みコントローラに信号送信
        // この例では単純にログ出力
    }
    
    // DMA統計情報
    getChannelStatus() {
        return this.channels.map(ch => ({
            id: ch.id,
            busy: ch.busy,
            transferCount: ch.transferCount
        }));
    }
    
    // システム全体の効率測定
    calculateEfficiency() {
        const busyChannels = this.channels.filter(ch => ch.busy).length;
        const utilization = (busyChannels / this.channels.length) * 100;
        
        return {
            channelUtilization: `${utilization.toFixed(1)}%`,
            activeChannels: busyChannels,
            queuedTransfers: this.transferQueue.length
        };
    }
}

// I/O装置シミュレーション
class IODevice {
    constructor(name, type) {
        this.name = name;
        this.type = type; // 'disk', 'network', 'graphics'
        this.busy = false;
        this.transferRate = this.getTransferRate(type);
    }
    
    getTransferRate(type) {
        const rates = {
            'disk': 150,      // MB/s (SSD)
            'network': 125,   // MB/s (1Gbps)
            'graphics': 500   // MB/s (PCIe)
        };
        return rates[type] || 50;
    }
    
    // デバイス固有のI/O操作
    performIO(operation, dataSize) {
        return new Promise((resolve) => {
            this.busy = true;
            const transferTime = (dataSize / this.transferRate) * 1000; // ms
            
            console.log(`${this.name} ${operation}: ${dataSize}KB transfer started`);
            
            setTimeout(() => {
                this.busy = false;
                console.log(`${this.name} ${operation}: completed`);
                resolve();
            }, transferTime);
        });
    }
}

// 使用例
const dma = new DMAController();
const disk = new IODevice('SSD-0', 'disk');
const network = new IODevice('NIC-0', 'network');

// 大容量ファイル読み込みのDMA転送
dma.requestTransfer({
    source: 0x100000,      // ディスクバッファアドレス
    destination: 0x200000, // メインメモリアドレス
    count: 1024 * 1024,    // 1MB転送
    direction: 'read',
    priority: 5,
    callback: (channelId, status) => {
        console.log(`File read completed on channel ${channelId}: ${status}`);
    }
});

// ネットワークパケット送信のDMA転送
dma.requestTransfer({
    source: 0x300000,      // メインメモリアドレス
    destination: 0x400000, // ネットワークバッファアドレス
    count: 64 * 1024,      // 64KB転送
    direction: 'write',
    priority: 7,
    callback: (channelId, status) => {
        console.log(`Network send completed on channel ${channelId}: ${status}`);
    }
});

// システム効率の監視
setInterval(() => {
    console.log('DMA Efficiency:', dma.calculateEfficiency());
}, 2000);

時刻  1  2  3  4  5  6  7
命令1 F  D  E  W
命令2    F  D  E  W
命令3       F  D  E  W
命令4          F  D  E  W

F: フェッチ, D: デコード, E: 実行, W: ライトバック
                

パイプライン化により、4命令を7クロックで実行（非パイプラインでは16クロック）