JS के साथ कंप्यूटर सिस्टम का निर्माण? [बन्द है]

Question

मैंने हाल ही में इस पुस्तक को समाप्त किया है जिसका नाम है द कम्पलिटिंग सिस्टम्स के तत्व जहाँ आप आधार से लॉजिक गेट्स से काम करने वाले कंप्यूटर सिस्टम का निर्माण करते हैं, अपने स्वयं के मशीन कोड और असेंबली लैंग्वेज बनाने के लिए, इंटरमीडिएट कोड के लिए, और अंत में एक साधारण ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा जो VM कोड के लिए संकलित है। मुझे इसमें बहुत मज़ा आया और मैं जावास्क्रिप्ट में कुछ समान बनाना चाहता हूं, लेकिन अधिक सुविधाओं के साथ। मैंने पहले ही JS में हैक मशीन के लिए एक एमुलेटर लिखा है:

  // Creates a new CPU object that is responsible for processing instructions
  var CPU = function() {

var D = 0;    // D Register    
var A = 0;    // A Register
var PC = 0;   // Program counter


// Returns whether an instruction is valid or not
var isValidInstruction = function(instruction) {
    if (instruction.length != 32)
        return false;

    instruction = instruction.split(""); 

    for (var c = 0; c < instruction.length; c++)
    {
        if (instruction[c] != "0" && instruction[c] != "1")
            return false;
    }

    return true;
};  


// Given an X and Y input and 6 control bits, returns the ALU output
var computeALU = function(x, y, c) {

    if (c.length != 6)
        throw new Error("There may only be 6 ALU control bits");

    switch (c.join(""))
    {
        case "000000": return 0; 
        case "000001": return 1; 
        case "000010": return -1; 
        case "000011": return x; 
        case "000100": return y; 
        case "000101": return ~x;
        case "000110": return ~y;
        case "000111": return -x; 
        case "001000": return -y; 
        case "001001": return x+1; 
        case "001010": return y+1;
        case "001011": return x-1;
        case "001100": return y-1;
        case "001101": return x+y;
        case "001110": return x-y;
        case "001111": return y-x;
        case "010000": return x*y;
        case "010001": return x/y;
        case "010010": return y/x;
        case "010011": return x%y;
        case "010100": return y%x;
        case "010101": return x&y;
        case "010110": return x|y;
        case "010111": return x^y;
        case "011000": return x>>y;
        case "011001": return y>>x;
        case "011010": return x<<y;
        case "011011": return y<<x;

        default: throw new Error("ALU command " + c.join("") + " not recognized"); 
    }
}; 


// Given an instruction and value of Memory[A], return the result
var processInstruction = function(instruction, M) {

    if (!isValidInstruction(instruction))
        throw new Error("Instruction " + instruction + " is not valid");

    // If this is an A instruction, set value of A register to last 31 bits
    if (instruction[0] == "0")
    {
        A = parseInt(instruction.substring(1, instruction.length), 2);

        PC++; 

        return {
            outM: null,
            addressM: A,
            writeM: false,
            pc: PC
        }; 
    }

    // Otherwise, this could be a variety of instructions
    else
    {
        var instructionType = instruction.substr(0, 3);
        var instructionBody = instruction.substr(3);

        var outputWrite = false; 

        // C Instruction - 100 c1, c2, c3, c4, c5, c6 d1, d2, d3 j1, j2, j3 (000..000 x16)
        if (instructionType == "100")
        {
            var parts = [ "a", "c1", "c2", "c3", "c4", "c5", "c6", "d1", "d2", "d3", "j1", "j2", "j3" ];
            var flags = {}; 

            for (var c = 0; c < parts.length; c++)
                flags[parts[c]] = instructionBody[c]; 

            // Compute the ALU output
            var x = D;
            var y = (flags["a"] == "1") ? M : A; 
            var output = computeALU(x, y, [flags["c1"], flags["c2"], flags["c3"], flags["c4"], flags["c5"], flags["c6"]]); 

            // Store the result
            if (flags["d1"] == "1") A = output; 
            if (flags["d2"] == "1") D = output;
            if (flags["d3"] == "1") outputWrite = true; 

            // Jump if necessary
            if ((flags["j1"] == "1" && output < 0) || (flags["j2"] == "1" && output == 0) || (flags["j3"] == "1" && output > 0)) 
                PC = A;
            else
                PC++; 

            // Return output
            return {
                outM: output,
                addressM: A,
                writeM: outputWrite,
                pc: PC
            }; 
        }

        else throw new Error("Instruction type signature " + instructionType + " not recognized");
    }
}; 


// Reset the CPU by setting all registers back to zero
this.reset = function() {
    D = 0;
    A = 0;
    PC = 0;
}; 


// Set the D register to a specified value
this.setD = function(value) {
    D = value;
}; 


// Set the A register to a specified value
this.setA = function(value) {
    A = value;
}; 


// Set PC to a specified value
this.setPC = function(value) {
    PC = value;
};


// Processes an instruction and returns the result
this.process = function(instruction, M) {
    return processInstruction(instruction, M); 
}; 
}; 

मैं एक फाइल सिस्टम, साउंड, इंटरनेट कनेक्टिविटी और RGBA स्क्रीन आउटपुट जैसी चीजों को जोड़ने के बारे में सोच रहा था (वर्तमान में यह केवल काला और सफेद है)। लेकिन यह वास्तव में कितना व्यावहारिक होगा?

क्योंकि मैं जो करने के बारे में सोच रहा हूं वह पूरी तरह से खरोंच से शुरू हो रहा है । और मेरे कहने का मतलब यह है कि अपना मशीन कोड बनाएं, फिर सी-लाइक लैंग्वेज की तरह काम करें और वास्तव में वर्किंग प्रोग्राम और सामान बनाएं।

Comments

यह पूरी तरह से संभव है। bellard.org/jslinux

— वर्ल्ड इंजीनियर

बस इसके लिए जाएं और देखें कि आप कितनी दूर हैं। यहां तक ​​कि अगर आप अपने अंतिम लक्ष्य में विफल रहते हैं, तो मुझे यकीन है कि आप टन सीखेंगे, और ऐसा लगता है कि यह आपकी मुख्य प्रेरणा है।

— जेम्स

तार का उपयोग न करें, जावास्क्रिप्ट 32 बिट पूर्णांक और उन पर

— बिटवाइज

संख्या केवल वास्तविक "खराब" भाग आईएमओ है।

— एरिक रेपेन

इसके अलावा, यह मुझसे पूछना चाहता है। क्या किसी भी गतिशील व्याख्या वाली भाषा में कभी इसके और मशीन की भाषा के बीच कोई परत नहीं थी?

— एरिक रेपेन

Answer 1

आप निश्चित रूप से कर सकते थे। आपको अपने ऑपरेटिंग सिस्टम के कुछ घटकों को लागू करने की आवश्यकता होगी, जैसे कि बूट लोडर, और निचले स्तर की भाषा में व्यवधान।

प्रबंधित कोड पर चलने वाले ऑपरेटिंग सिस्टम को कैसे विकसित किया जाए, इसके बारे में Microsoft द्वारा सिंगुलैरिटी ऑपरेटिंग सिस्टम द्वारा लिए गए दृष्टिकोण पर एक नज़र डालें ।

बेशक, इस बात की कोई आवश्यकता नहीं है कि आपको मेमोरी प्रबंधन पर जावास्क्रिप्ट करना होगा, आप मेमोरी प्रबंधन के लिए एपीआई को जावास्क्रिप्ट में जोड़ सकते हैं। आप जावास्क्रिप्ट के लिए एक कंपाइलर लिखना या एक वर्चुअल मशीन लिखना चुन सकते हैं।

विलक्षणता के पास स्रोत कोड उपलब्ध है ताकि आप Microsoft द्वारा किए गए डिज़ाइन निर्णयों को देखने से बहुमूल्य जानकारी प्राप्त कर सकें।