Fall 2008 Operating Systems

Missing operands

2008-12-16T16:33:00.002-05:00

This one has had me puzzled since Project 3. How exactly are we supposed to tell if an operand is missing?

As far as I can see, we can't. If a user enters a program, and forgets an operand, and instead enters the next instruction, that's what we're going to retrieve instead.

This is either going to cause one of two things:

1. Abnormal program results

2. A memory access error if the value is high enough (greater than 128.)

The second one is something we can prevent. If it occurs, terminate the program. But that is a memory access error, and something totally separate from a missing operand error.

Any thoughts on this?

What to do about User Program I/O

2008-12-15T16:53:00.006-05:00

Rather than "Read From a File" and "Write to a File", let's recast those operations as "Read the First Block from a File" and "Write the First Block of a File". That way we can stop worrying about the number of bytes.

So...

Read the First Block from a File
X: 03
Y: start address of file name
A: starting address at which to begin saving the read bytes.

Write the First Block of a File
X: 04
Y: start address of file name
A: start address of the string to write to the first block of filename.

Good luck. If you want to implement something more robust, you are of course free to do so.


<PICARD>
     Make it so.   
</PICARD>

Disk I/0 request query

2008-12-13T16:57:00.002-05:00

When the currently executing process makes a disk I/O request
o Move the current process to an I/O queue to wait while its I/O request is [required]
being serviced.
o Invoke the scheduler to get the next process on the Ready Queue (RQ) [required]
o Once the I/O request is complete, take the waiting process off the I/O Queue [required]
and put it back on the Ready Queue. (Be sure to keep track of any data
returned from the I/O operation.)

We are really confused?

Do we need to use the ready queue here? Fo we call this from the shell or create our own program.

Clarification Please

2008-12-08T02:59:00.002-05:00

Add System Call handlers to allow the user program to perform disk I/O. [required]

o Read from a file

• X: 03

• Y: start address of the file name

• A: name number of bytes to read

• ?: start address to save read bytes

o Write to a file

• X: 04

• Y: start address of the file name

• A: start address of string to write to file.

What is needed from us to do for this specific task.

Which I think CJ touched on this topic

Read System Call

2008-12-08T00:32:00.001-05:00

I don't think we decided on what to do for the read system call. Were we going to add another register for the address to store the retrieved data or were we just gonna print it out on the console without storing. Or is this up to us?

Handling FSDD Interrupts

2008-12-03T21:25:00.003-05:00

It seems there is much confusion on how to handle the interrupts from the FSDD. Especially since we are

Did we not, early in the year, want these file operations to be system call interrupts handled in the kernel?
I think Alan even left comments in the base code in kernel.js as a TODO to add in these kernel functions as SYSTEM CALL ISRs.

Getting the next available block

2008-12-03T15:49:00.002-05:00

So, what is the most efficient, least time consuming method to go about finding the next available block.

A combination of brute force/back tracking would have us search like this for an available t,s,b:
Check 1,0,0..1,0,1...all the way to 1,0,7 now if we do not find an avail block to write to...
Keep checking...1,1,0..1,1,1....all the way to 1,1,7 now if we still do not find an available block to write to...
Keep checking untill all permutations/combinations of (0,1,2,3)(0,1,2,3,4,5,6,7)(0,1,2,3,4,5,6,7) are searched sequentially....

And since we are searching sequentially, you can bet that our fsdd is handling writes sequentially...so the more data we write the longer it will take by the time we get to writing data to our last file.

Also what this results in is contiguous blocks of data, which becomes a form of a sequential data set of sorts, rather than having uncontiguous, partitioned blocks of data. Until that is, we decide to overwrite blocks (which, by using this method of checking sequentially for an available block, will not have to happen until we've written to the last block at 3,7,7)

Plus the run time jumps up the wazzooo just to write data because you are waiting potentially for a terrible worst case of some function only Ten Eyck could really compute and determine...which usually means a ridiculously large function that grows terribly fast.

So what is a more optimal solution to this approach of obtaining the next available block?

SJAX: Synchronous Javascript and XML

2008-12-02T15:01:00.002-05:00

It's like AJAX, but with blocking and waiting for a (yes, slow... I know) response. See here.

Filesystem Standardization?

2008-12-02T12:43:00.002-05:00

Can we explicitly declare the standardizations for the file system Scott was talking about using (if we are going to do that.) It could be posted on the site or here by Alan, it doesn't matter to me, just so long as we are all on the same "page". Perhaps we'll have to wait til class on Friday to discuss it, but any info would be useful.

Yawn..

2008-12-01T21:20:00.002-05:00

Anyone else experiencing dreadfully slow response time from Alan's server? Sometimes my AJAX calls take a few minutes to come back! :(

Chaining asynchronous AJAX calls

2008-12-01T01:56:00.013-05:00

As many of you have found out this project is a little tricky. Using the example AJAX calls that were provided, you may notice that they are asynchronous (funny isn't it? being that AJAX = asynchronus javascript and XML). This means that after the call is made, javascript continues executing the next (javascript) line of code without waiting for a response from the server (Alan's in this case).

This is a problem when we have a chain of calls that depend on each other, such as the calls needed to create, read, write, and delete a file on our remote "hard drive". For example, to write to a file we must first look up the file in the file listing directory and get its first block. From there we must either write to that first block, or check if theres another block free (if its over 24 bytes). Before we can do any of that, we need the response from the original AJAX call. How do we tell that next command to chill out until we receive a response from the previous one?

I think this is what Alan was getting at in the response to Joe's post...This is my solution, not sure if it's the best but it solves the problem.

Create some kind of a data structure (not a traditional queue) to keep track of AJAX IO Requests (I stored this data structure right in my FS device driver). Create an object to represent an IO Request. This IO request object should contain these three fields (in some form)

- A unique FileIO Request ID (will not change throughout the IO Request Object's lifetime
- The type of request it is (create, read, write, delete, (and format, but probably not necessary until the final project))
- The stage/phase it is in - think of the IO Request object as stateful - what step is it doing in the chain of requests?
- Other various variables that are unique to the type of request (data to be written, file name, blocks that its going to write to...etc). I think an associative array is an appropriate way to handle these miscellaneous variables

Then, in the FS Device Driver, I made 2 functions for each operation. The first one initialized the chain of requests, the second one was the function that gets called back by the AJAX requests.

An example - createfile
createfile(filename) would do the following -

- create a IORequest object and give it a unique ID (keep a variable with the last one given an increment it)
- set the type to create
- set the phase to something like ' looking up directory entry 1'
- in the associative array, store the filename for later
- kick off an AJAX read request of the first directory entry

The create file callback function would take the data fetched from the server as well as the IORequest ID. First it fetches the IORequest object, checks the phase, and performs whatever is necessary to complete the request, including possibly sending off another AJAX request (this callback function could be invoked multiple times with the same IO request ID). When it's done with the entire operation (entire chain of commands) it spits out a confirmation message or an error message (make sure you use the STDOUT ISR) and deletes the IO Request from the storage data structure.

I think once you conceptualize it, it makes more sense to do it in a stateful fashion (I can't think of any other way to do it).

The only tricky part in this is telling the AJAX request to return to the correct callback function and pass it the correct requestID.

I modified the example 'readBytes' function we were given to accept a callback function, and instead of passing JQuery the function that alerts the data, it will invoke our own callback function. It looks like this:


function hdReadBytes(track, sector, block, callback)
{

  var getUrl = "http://www.3nfconsulting.com/msdos/GetBlock.aspx?" + 
    "u=" + escape(DISK_USER) + 
    "&t=" + escape(track) + 
    "&s=" + escape(sector) + 
    "&b=" + escape(block);
  $.getJSON(getUrl + "&format=json&jsoncallback=?", 
      callback
     ); 
}

We cannot simply pass in our createFileCallback function, because the function that JQuery calls after a response will only get passed one parameter: the response from the server. We need to pass it a function that will take the response as a parameter, and then invoke our callback function with the response as well as the request ID. I did this by creating a function that creates function (sound like scheme???):


function fsDDBuildCallback(requestID, callbackFn)
{

  // Creates a function that we can pass to JQuery - only accepts
  // one parameter which is the response from the server
  var fn = function(data)
  {
    // JQuery is going to pass us an associative array with 
    // an element with the key 'data' that contains the file system response
    //
    // Pass the request ID that we're calling this from, with the server's
    // response into the callback function that we want to invoke
    callbackFn(requestID, data['data']);
  };

  return fn;
}

We would use this like this (end of createFile):


  // Start by reading 001, where the directory starts
  this.hardDrive.readBytes(0, 0, 1, 
      this.buildCallback(requestID, this.createFileCallback));

The only thing to look out for, is in your callback functions, using 'this' to call a function as part of the FS Device Driver (or wherever your calling it from) won't work. This is because the function is getting evaluated within a different object (I'm guessing a JQuery object when it calls 'eval'...either that or the window object). You must refer to it as the global name (ie name it in the kernel and call it like that..._krnFSDD instead of this). Theres some really good articles out there on javascript scoping, this one I particularly liked: http://alternateidea.com/blog/articles/2007/7/18/javascript-scope-and-binding

The good thing about this is that its all useful for our final project. We'll create an IO PID queue that has the PID's that called these operations. After the final write request comes back (or we may want to risk it and not wait for a confirmation), we'll context switch back into the appropriate process that was on the IO PID queue.

Hope that helped somebody...good luck!

By the way...anybody see an easier way to do it?

Mount/Unmount vs Swapping in FSDD's

2008-11-28T22:35:00.002-05:00

If we are going to be making this so that we can plug in anybodies fsdd without error, why do we not just make a mount/unmount command to a specified users file system location in the database?

One- this elminitates from having to restart the OS and re-loading the fsdd so that its a "hot-swappable" drive so to speak, in imaginary OS land.

Two- it creates a global fsdd for everybody and gets everyone on the same page. I know I know, what distributed pc OS has the ability to hot swap a harddrive? Idk of any, but think of this as something like z/VM or linux on z, and just swapping in and out DASD volumes...

Think about it, your FSDD is up and running, and you are mounted at your own directory. well if you want to write to someone elses, you can issue a mount command and this opens up data communications as well. The only thing that sucks is write locks would have to be put in place to keep everything synchronized and people from writing to the same directory at once, or grabbing data that has just been overwritten.

Just a thought...

JQuery not syncronizing?

2008-11-22T22:42:00.003-05:00

Not sure if going to explain properly but been working on getting/setting blocks and have a problem with getting. Setting is no problem since you don't need any response from the web service. But getting is a problem. The jquery will report the result in a krnTrace fine, but when trying to actually save the data seem to have a problem. It is going past the jquery while it waits and calling the rest of the code. I've even added alerts to give the jquery time to finish but still no luck.

Currently the only thing able to figure which might work is adding the get block to return to a queue, then later time can retrieve off of it. This might work, but trying to implement this seems a little more complicated then would seem. Thinking work liek a deli line, giving each request a unique id, then somewhere would have to look for that id, or wait for it to pop up? I'm not sure up to this since haven't tried the queue yet, going to do this now. Wondering if anyone else actually got getblock to store to a variable you can retrieve later, and not just display in the krntrace.

edit...
Well after testing out the queue seems like the scope inside the json function doesn't reach outside tot he class variable... Which would explain why I am not able why when I used a global variable to store the same thing I was krnTracing, I was unable to retrieve.

Disk I/O Time, another queue!!1

2008-11-21T12:50:00.021-05:00

Update: I s'pose I should update this. As Alan points out in a later post, this isn't for iP4, which deals with the kernel-level stuff and the FS/disk drivers. This stuff comes into play when we introduce syscalls for disk I/O. Rob's newer, and much more technical post, mentions I/O queue stuff as well.
--

One of the issues brought up after class today was about the amount of time that disk reads and writes are going to take. Because it's going over the Internet, the entire request is probably going to take more than, say, 0.5 sec, or whatever the clock tick interval is. So, if a program is trying to write to disk, it might not finish before the next CPU cycle executes.

Obviously, this poses a problem. One solution would be just to "pause" the CPU, by setting whatever flag for cpuExecuting to false. This isn't very realistic, though, as what normally happens in "real" OSs (if there is such a thing), is that the currently running process (the one just just made the disk I/O request) is moved to a queue to wait while its I/O request is being serviced, something like the I/O queue (IOQ).

So, with the CPU open to execute another process, we just invoke the scheduler to get the process on the front of the Ready Queue (RQ) to start/continue executing. The OS continues to run as normal. Once the I/O request is complete -- that is (I think), the JSONP callback method finishes, we look for the corresponding process in the IOQ, and move it back to the RQ. From there, the scheduler continues running as normal. I'm not sure how we keep track of what process made what disk I/O request, and associating the JSONP callback with a process or whatnot, but we'll figure that out somehow.

The order of PCBs on the IOQ doesn't really mean all that much at this point, it'll just be the order of requests for disk I/O. When that request is serviced, we may have to search through the IOQ for the process we're looking for before moving it back to the RQ.

Totally and completely off topic:

2008-11-18T09:18:00.002-05:00

This has nothing to do with the project, but I figured A-train would get a kick out of it. You know how he mentioned the MOS 6502 processor powered Bender on Futurama?

This guy made a Bender to hold his beer brewing bucket, and controls it with none other than an MOS 6502 processor.

The processor details are on the second page, complete with a circuit diagram.

Okay, back to work now. Nothing to see here.

Gracefully handle errors in the CPU?

2008-11-06T14:51:00.003-05:00

Did we ever decide on what this means? I would assume to terminate the process and display an error message. It seems like it would be really dangerous to the user to just continue on to the next operation...

Branch OP Code

2008-11-05T16:54:00.002-05:00

How exactly does this work? I understand what it's doing, but I'm not completely clear on how the EF operator it is taking works.

If someone could kindly explain, it would be appreciated.

Displaying output while having an active prompt

2008-11-03T16:29:00.007-05:00

I came up with a somewhat sleezy hack to the problem Bedell mentioned in the earlier post.

The problem was, allowing the user to enter text while there is output coming back from jobs currently running in the CPU. While he typed, he would get the output strings mixed in with his typing and it would be hard to read.

In short, this is how it works:

1. An interrupt comes in to display output to std out.
2. Clear the current line
3. Display the output
4. Break to the next line
5. Re display the prompt
6. Display what the user had currently been typing again.

In code this translates to: (in kernel.js in your interrupt handler)


          _StdOut.clearCurrentLine();
          _StdOut.putText(params);
          _StdOut.advanceLine();
          _OsShell.putPrompt();
          _StdOut.putText(_StdIn.buffer);

This is a little sloppy and violates a bunch of laws, using calls from _StdOut and _OsShell, but like I said its a hack that is probably good enough for iProject3.

We already have methods available to do everything above except for clearing the current line.

To add support for clearing the current line, we need to first add this to console.js in your constructor:


    this.clearCurrentLine = consoleClearCurrentLine;

and add this as one of your methods:


function consoleClearCurrentLine()
{
  this.CurrentXPosition = 0;
  DRAWING_CONTEXT.clearLine(this.CurrentYPosition);
}

Now add this to canvastext.js


CanvasTextFunctions.clearLine = function(ctx, y)
{
  ctx.clearRect(0, y - DEFAULT_FONT_SIZE, CANVAS.width, DEFAULT_FONT_SIZE + FONT_HEIGHT_MARGIN);
};

and add this to the method CanvasTextFunctions.enable (at the bottom of the file):


    ctx.clearLine = function(y) { return CanvasTextFunctions.clearLine(ctx, y); };

And that should be it, unless I forgot something. It's a bit ugly, but it does the trick.

CPU cycles, Interrupt handling, and saving the stack

2008-11-01T16:22:00.014-04:00

Thinking about Rob's question and Dan's answer (prior post, below) along with our discussions yesterday in class and after, I decided to write a small version of the solution we collectively came up with. Taking the original "baseline" project from week 1, I added or changed the following major areas:

The hardware simulation creates the CPU and wires up the CPU pulse to call krnOnCPUClockPulse() in the kernel.


function simBtnStartOS_click(btn)
{
// Disable the start button...
btn.disabled = true;
// .. enable the Emergency Halt and Reset buttons ...
document.getElementById("btnHaltOS").disabled = false;
document.getElementById("btnReset").disabled = false;
// .. set focus on the OS console display ...
document.getElementById("display").focus();
// ... Create and initialize the CPU.  Then set the clock pulse simulation to call into the Kernel.
_CPU = new cpu();
_CPU.init();
hardwareClockID = setInterval(krnOnCPUClockPulse, CPU_CLOCK_INTERVAL);
// .. and call the OS Kernel Bootstrap routine.
krnBootstrap();
}

Instead of an event loop, we let the CPU pulse trigger OS events. This synchronizes everything pretty nicely.


function krnOnCPUClockPulse()
{
  // Update the OS clock.  (It's useful for meaningful log entries and perhaps other things in the future.)
  _OSclock++;  
  if (_KernelInterruptQueue.getSize() > 0)    // Process a pending interrupt, if any.
  {
      var interrput = _KernelInterruptQueue.dequeue();
      krnInterruptHandler(interrput.irq, interrput.params);  // Used to be named krnInterruptDispatcher.
  }
  else if (_CPU.isExecuting)                  // If not, then run a CPU cycle is there is anything to process.
  {
      _CPU.cycle();
  }  
  else                                        // If not, then just be idle.
  {
      krnTrace("Idle");
  }
}

We no longer need an explicit interrupt for CPU pulses. But the keyboard interrupt needs to work in a slightly different way, now enqueueing an interrupt object on the kernel's interrupt queue rather than calling krnInterruptHandler() directly.


function simOnKeypress(event)
{
    if (event.target.id == "display")
    {
        event.preventDefault();
        // Note the pressed key code in the params (Mozilla-specific).
        var params = new Array(event.which, event.shiftKey);
        // Enqueue this interrupt on the kernal interrupt queue so that it gets to the Interrupt handler.
        _KernelInterruptQueue.enqueue( new Interrput(KEYBOARD_IRQ, params) );
    }
}

A bare-bones CPU object.


function cpu()
{
  this.PC    = 0;     // Program Counter
  this.Acc   = 0;     // Accumulator
  this.Xreg  = 0;     // X register
  this.Yreg  = 0;     // Y register
  this.Zflag = 0;     // Z-ero flag (Think of it as "isZero".)
  this.isExecuting = false;

  this.init = function()
  {
      this.PC    = 0
      this.Acc   = 0;
      this.Xreg  = 0;
      this.Yreg  = 0;
      this.Zflag = 0;    
      this.isExecuting = false;
  }

  this.pulse = function()
  {
      // TODO: Do we need this? Maybe not.
  }

  this.cycle = function()
  {
      krnTrace("CPU cycle");
      // Do real work here.  Set this.isExecuting appropriately.
  }
}

I tested this by setting CPU_CLOCK_INTERVAL = 10 so the clock pulses 100 times per second. I then altered simLog() to show entries every 100,000 ticks, or every 1000 seconds, or about once every 16.67 minutes. (That way I could run it a long time without lagging the browser with a huge log.)

As of this writing, I'm up to 800,000 clock cycles and Firefox on my Mac is still running just fine. It's responsive. (It's taking between 5% and 7% of my real processor time.) My OS is responsive as well. I can type shell commands and they execute fine as well. This means we can definitely interact with the shell in kernel mode while the CPU is executing user code at the same time.

Context switching through interrupts???

2008-10-28T21:48:00.006-04:00

Bedell and I are discussing the idea of context switching through interrupts, and either I'm overlooking something, or this may present a platform specific issue (JS).

The way I understand it, is we use the shell to kick off the job scheduler. The job scheduler calls the CPU, which when its done with its desired of clock cycles in RR, it calls an interrupt to do a context switch. The kernel then calls the job scheduler, which switches the process, runs the process, calls the context switch after desired clock cycles etc etc etc.

My problem with this, is that we're pretending that the CPU is hardware. As much as we close our eyes and bang our red shoes together, its not. Unless Javascript has some secret capability for multi-threading, this brings up a huge problem.

What is our browser call stack going to look like? We're never returning from any of those calls (interrupts, task scheduler, and cpu calls - which are all methods, even the cpu stuff), so ultimately we're going to have way too many calls stacked up in this huge loop.

For example, lets say we load 3 programs into memory with 100 instructions each, and set our RR quantum to 1 and kick off our scheduler. Thats 300 context switches, and for every context switch we have to make 1 call from task scheduler, 1 call from cpu to kernel interrupt, and 1 call back to the task scheduler. thats 300 * 3 = 900 calls.

What if we wanted to run programs that actively computed things until the user closed them out, for example a text editor. This would go on for too long, and eventually Firefox would probably crash/light on Fire (no pun intended).

Now maybe we're not going to run any programs with 100 instructions, or no programs that exist in memory indefinitely, but it still seems a bit sloppy.

Right before iProject2 was due I had a conversation with Danner and Bedell about something similar. The way I thought we had decided seemed the most logical involved polling. The solution was to have the task scheduler call the CPU for the desired number of clock cycles, and then the CPU returns (probably with some kind of status message for done, awaiting user input, etc). The task scheduler then checks if there were any other interrupts (a flag in the kernel?) and then either handles the interrupts, or does a context switch, passes control back to the CPU, rinse and repeat.

This also (I think) solves the problem with how do we acknowledge a hardware interrupt when the CPU is in use. By polling for that interrupt flag before every context switch, we can determine if we should switch to something more important. (This is assuming Firefox can handle an event while Javascript is already crunching in the background - it is multithreaded).

Any thoughts on this or am I overlooking something obvious?

Memory

2008-10-27T12:11:00.002-04:00

Ok, I'm a bit confused about this whole memory thing, and what is supposed to be doing what.

Let me review what I know first.

In the Hardware simulation we have:
The actual Memory object
A hardware memory manager

In the Kernel object:
A software memory manager

Memory is going to consist of 384 bytes, divided into 3 pages of 128 bytes each.

So, here comes the questions...

What handles the pages? Are they part of Memory, or one of the memory managers?

What are these two memory managers doing, and how do they talk to each other?

TextArea

2008-10-08T00:35:00.002-04:00

I am trying to show my contents of memory. However when I set the value to each indexed word in memory, it just keeps overwriting the string value on the first line of the textarea.

I tried moving down a line by using \n and even \r\n and it still will not move down a line in my text area.

Does anyone have any hints or tips for this?

Process Control Blocks

2008-10-07T14:12:00.002-04:00

I've been doing some reading about process control blocks (PCB) and I've come across something I don't completely understand.

I've seen this in a couple of places, and they all mention that the PCB holds the register contents.

The thing that confuses me is: Don't the registers also hold their contents?

When is the PCB responsible for holding register contents? Is it only when the CPU has switched away from the process to another process?

Memory Management Unit

2008-10-07T09:34:00.003-04:00

You folks won't really need the MMU until iProject 3, but it's worth thinking about know.

I've been pondering:
The CPU is (obviously) hardware, executing user code in user mode. The user code communicates with the OS via system calls (also known as software interrupts). But what about mapping virtual memory addresses to physical ("real") memory addresses? The user code knows nothing about this -- it cannot -- so there can be no system calls for it. How does it work?

Does the CPU somehow ask the OS? No. The CPU asks the MMU. But where's the MMU?

The MMU is a hardware element, either separate from the CPU, or on some systems, like the Intel 80x86 where x >=2, integrated with the CPU. It's not part of the OS as far as real memory is concerned. There is an OS portion for virtual memory management, but we'll get to that later on in the semester.

Put your MMU.js file in the simulation directory and consider it as part of the hardware.

Better on keypress fix

2008-10-03T13:30:00.005-04:00

This will set focus to your canvas when you click Start, and also will fix the '/', backspace, and space bar problems where firefox was grabbing them.

in index.html add tabindex = "1" to your canvas class


<canvas id="display"
                    width="500px"
                    height="500px"
                    tabindex="1">
</canvas>

then in hardwareSimulation.js in function simOnKeypress(event) change


if (event.target.id == "")


if (event.target.id == "display")

Also make sure you add the "()" to the end of event.preventDefault in that if block.

Keyboard device driver

2008-09-26T22:00:00.003-04:00

Since there's been some discussion about how to implement this, I'll toss my hat in the ring, and explain how I did it.

I did use a two dimensional array. The array is initially indexed on the keyCode values. Then once the correct keyCode is found, position 0 is devoted to the 'unshifed value', while position 1 is the 'shifted' value.

Code looks something like this.

 
function declareKeyboardArray()
{
    keyCodeArray[65] = ['a', 'A'];
    keyCodeArray[66] = ['b', 'B'];
    keyCodeArray[67] = ['c', 'C'];
}//end function

//KeyCode tests look like this
//Only tested for the three values I declared above
if ( (keyCode >= 65) && (keyCode <= 67) )
{
    if(isShifted)
    {
        outputChr = keyCodeArray[keyCode][1];
    }//end if
    else
    { //Key is not shifted
        outputChr = keyCodeArray[keyCode][0];
    }//end else
}

JavaScript and Hexadecimal

2008-09-26T14:40:00.004-04:00

Thank the heavens, JavaScript supports hexadecimal variables.

You declare them just as you would any other variable, and the value you assign must be prefixed by "0x" just as any other hex number representation.

Here are some tests I ran on an online interpreter (http://mochikit.com/examples/interpreter/).

  
>>> var hex = 0x10;
>>> hex;
16

>>> var hex = 0x10;
>>> var dec = parseInt(hex,16);
>>> dec;
22

>>> var hex = 0x10;
>>> var dec = parseInt(hex,10);
>>> dec;
16

>>> var hex = 0x10;
>>> var dec = parseInt(hex,10);
>>> var hex2 = dec.toString(16);
>>> hex2;
"10"

>>> var hex = 0x10;
>>> var dec = parseInt(hex,10);
>>> var hex2 = dec.toString(16);
>>> var dec2 = parseInt(hex2,16);
>>> dec2;
16

deviceDriverKeyboard error

2008-09-24T11:16:00.002-04:00

In case anyone hasn't finished the keyboard driver, I figure I'll point out an error in the code we were given. In krnKbdDispatchKeyPress function, the second if statement checks for keycodes between 65 and 90, and 97 to 123. The second set is not needed, since the keycode for letters will always be between 65 and 90. The check for isShifted corrects for lowercase.

97 - 123 happens to include 109, if anyone was wondering why the "-_" key was giving them "m" when shifted, and an unprintable character when not.

Scrolling with getImageData and putImageData

2008-09-22T20:35:00.007-04:00

I never got the canvas working properly for the first assignment. This is the scrolling code I have:


if ((this.CurrentYPosition +
       DEFAULT_FONT_SIZE +
       FONT_HEIGHT_MARGIN) >=
    (CANVAS.height-20))
{
    var img;
    img = DRAWING_CONTEXT.getImageData(
        0,
        (DEFAULT_FONT_SIZE + FONT_HEIGHT_MARGIN),
        CANVAS.width,
        (CANVAS.height - 20 -
          (DEFAULT_FONT_SIZE + FONT_HEIGHT_MARGIN)));
    
    //copy subtracts taskbar and line height.
    consoleClearScreen();
    DRAWING_CONTEXT.putImageData(img, 0, 0);
}

This works perfectly, the only issue is that there is a six second lag whenever the screen scrolls. Any hints where I'm going wrong?

Partial "FIX": Firefox reaction to certain keys

2008-09-19T01:08:00.011-04:00

I think found the issue:

In hardwareSimulation.js
function simOnKeypress()

Line:
event.preventDefault;

preventDefault is a function, so all that line does is access the property, returning the function code itself.

The fix: add parens:
event.preventDefault();

The only annoyance about this is it also disables F5, and event.which returns a code of 0.

See a more recent post for the proper fix for this.

---
The "legacy" solution:

In this case, though, event.keyCode has something meaningful, so you can use this to selectively enable (or rather, not disable, horray for double negatives) F5 to be handled by Firefox (if so desired):


if (116 != event.keyCode) // F5 => keycode of 116
{
    event.preventDefault();
}

Browsers are lovely...

Firefox reaction to certain keys

2008-09-18T12:22:00.002-04:00

I've noticed in my testing that Firefox has programmed responses to certain keys. The ones that are really a problem are single quote and /. Pressing either of these launches the Quick Find feature on me.

Backspace also fires the back button on the browser. I do have a workaround for that at least. Just open the OS project in a new tab.

Anybody else encountered these, or have a workaround?

StdIn and StdOut

2008-09-17T17:36:00.002-04:00

This has been bugging me, since I started looking at the code.

From what I remember of C programming, you usually read from the StdIn stream, and write to the StdOut stream.

At the moment, all the console window output is being written to the _StdIn reference to the console window. Should we be using _StdOut instead?

I realize this might not matter too much right now, but it might become important, as this project gets more complex

Scrolling

2008-09-16T13:32:00.002-04:00

Any ideas on scrolling besides keeping an array of all the lines on the screen, then redrawing each time? I tried canvas.translate, but I can't make it work. I found something about scrollbars, but that sounded like a Javascript function, and not quite what he wants us to be doing.

whereami command

2008-09-15T21:43:00.002-04:00

So, I meant to stop by and ask Prof Labouseur about this, but I forgot.

Is there actually a way to get geographical location with the "whereami" command? I assume some sort of IP address lookup? How does one go about doing that?

Keycodes in Mozilla

2008-09-15T17:30:00.004-04:00

Ignore this, I didn't refresh the window before posting.

(Shoot, why is it saying NerfTheWarmech instead of Kris? I need to make a different account.)

Punctuation charcodes

2008-09-15T16:51:00.003-04:00

So, it turns out as Luis and I were testing punctuation in deviceDriverKeyboard.js that the charcodes for punctuation are suffering from a wonderful ascii to unicode conversion...

i.e. charcode for period (.) in ascii is 190
charcode for period (.) in unicode is 46

In the krnKbdDispatchKeyPress function....

This test threw alerts on the screen when period (.) was pressed on the console the first alert displayed the ascii charcode that was pressed...190 and then the second alert displayed the symbol 190 equates into unicode which is a (3/4) fraction symbol. (Kudos to Luis on testing).

I am working out an efficient way to convert if at all possible these charcodes to make punctuation friendly...

Any ideas of how to attack this? Or is there a workaround I am not seeing?

Log

2008-09-13T13:11:00.007-04:00

As it was mentioned in class, the textarea style log tends to lag the page up once it gets filled with a lot of text. Another thing that annoyed me was that new entries to the log were entered at the bottom, so the log would get longer but you couldn't see it without scrolling. So, I changed my log to use a div instead of a text area. Also modified the code so that newest entries to the log were placed at the top. If you would like a log like mine, here is what you have to do...

In 'index.html' find the text area with id 'taLog'. Delete the text area and replace with a div instead. Give the div an id and name of 'divLog' and a class of log.

Next in hardwareSimulation.js, in the simInit() function, replace:


    // Clear the log text box.
    document.getElementById("taLog").value="";

With..


    // Clear the log text box.
    document.getElementById("divLog").innerHTML="";

Also, in the simlog function, replace this


    // Update the log console.
    taLog = document.getElementById("taLog");
    taLog.value = taLog.value + str;

With..


    // Update the log console.
    divLog = document.getElementById("divLog");
    divLog.innerHTML =
        "<div>" + str + "</ div >" +
        divLog.innerHTML;

Lastly, in the .css file, add this:


.log
{
  height: 500px;
  width: 400px;
  background: white;
  overflow: scroll;
}

ed: syntax highlighting supports CSS too!

Now you should have an improved log!

Using for...in when adding methods to Array

2008-09-11T23:38:00.004-04:00

If you are going to use add methods to the base object Array (using prototype), you should be aware of the for...in iterator.

To get a better idea of what I'm talking about, I added several functions to some JS base classes. Here is an example of adding the contains method to Array:


/*
 * Uses Array#indexOf to check if there was a matching element.
 * Returns true if found, false otherwise.
 */
function contains(element)
{
    return (this.indexOf(element) != -1);
};

Array.prototype.contains = contains;

So I happily went along using this to parse shell args...until I started getting all these funny errors. It turns out that the for...in statement was causing this. Taken from http://www.w3schools.com/jS/js_loop_for_in.asp:

The for...in statement is used to loop (iterate) through the elements of an array or through the properties of an object.

The code in the body of the for ... in loop is executed once for each element/property.

This means it not only iterates through each element in the array, but whatever properties we have added to it (this includes methods). It would iterate through all elements and then through all added properties (in this case methods).

If you are going to extend Array, we probably want to change those for loops to a traditional for loop.

These for...in loops were used in the following locations:


scripts/utils.js:24:    for (var i in str)
scripts/os/queue.js:44:    for (i in this.q)
scripts/os/shell.js:116:    for (var i in tempList)
scripts/os/shell.js:238:    for (i in _OsShell.commandList)

Syntax Highlighting Test

2008-09-11T18:55:00.010-04:00

This is a test


function ontest()
{
  alert("This is only a test.");
}

See?
You have to use the XHTML "pre" tag in your post and give it a name and class, like so:

Very Cool. Thanks Dan.

ed: It supports a number of different languages; see here for the full list. Use the alias as the class.

JavaScript "Associative Arrays"

2008-09-08T13:35:00.080-04:00

JavaScript has support for "associative arrays", similar to what other languages (e.g. Perl, Ruby) have built in. They're used extensively in jQuery-land by the name of "Options Objects". They aren't, strictly speaking, associative arrays, but rather plain old JavaScript Objects. See here for an explanation.

In any case, using them is simple, and makes storing and passing data around easier. Keys and values can be of any type (string, number, Regexp, function, etc.), and an individual object doesn't have to be homogeneous. The keys usually work best if they're all strings (numbers can also be useful).


// create a new, empty object
var associativeArray = {};

associativeArray["key1"] = "value1";
associativeArray["key2"] =
    /\w+/g; // Regular expression
associativeArray["timeSliceQuantum"] = 10;
associativeArray["theAnswer"] = 42;

The key-value pairs can also be declared inline:


var anotherAssociativeArray2 = {
  "a" : "alpha",
  "b" : "beta",
  "c" : "charliehorse"
  // etc.
};

Accessing uses array syntax:


// access a value with a literal
var someVar =
    associativeArray["key1"]; // => "value1"

// access a value by a variable key
var someKey2 = "key2";
var anotherVar = associativeArray[someKey2];
  // => /\w+/g

You can also iterate over all the key-value pairs using a for-each-like syntax (note: see Rob's post above about using the for-each on regular arrays):


for (key in associativeArray)
{
  alert("Key: " + key +
        ", Value: " + associativeArray[key]);
}

The order that they are returned in here is implementation dependent. It may be in the order they were added (I think it is on most browsers), or it may not.

That's (pretty much) all you need to know to start using them. Come back here if you can't find a Calculus book late at night (sorry Alan, I'm stealing your lines again).

-----
Below is extra stuff that isn't really necessary, but useful to be aware of.

Accessing keys that weren't set returns undefined:


var someValue = associativeArray["pandaBears"];
   // => undefined

One gotcha: it's better (in my opinion) to specify keys as string literals (doesn't matter for values):


var apple = {
  "one" : "1",
  "two" : 2
};

...but, it's much more common to use the non-string version:


var apple = {
  one : "1",
  two : 2
};

Both have the same effect, but if there's a variable with the name of "one" in the current scope, it will be ignored as a key; "one" will be interpreted as a string literal and used as the key. Variables are properly handled as values, though:


var two = "2";
var apple = {
  "one" : "1", // "one" => "1"
  two : two    // "two" => "2"  !!!!!
};

// Set keys with a variable this way:
var three = "thr33";
apple[three] = "c"; // "thr33" => "c"

So, JavaScript associative arrays in a nutshell. They're awesomeness. Here's a snippet that covers more or less everything:


// Literal declaration:
var someKey3 = "key3";
var someValue3 = "value3";

var aa = {
  key1 : "value1" , // "key1" => "value1"
  "key2" : "value2" , // "key2" => "value2"
  someKey3 : someValue3
      // "weird" case: "someKey3" => "value3"
};


// Array-like notation:
var someKey5 = "key5";

aa["key4"] = "value4";
aa[someKey5] = "value5"; // "key5" => "value5"

// Yes, you can put functions as values, too.
aa["callbackFunction"] = function () {
    return 42;
  }

alert(aa[someKey5]); // => "value5"


// Iteration:
for (key in aa)
{
  var value = aa[key];
  alert(key + " = " + value);
}
/* Alerts should say:

value5
key1 = value1
key2 = value2
someKey3 = value3
key4 = value4
key5 = value5
callbackFunction = function() { return 42; }

*/

Code Enhancements from Class One

2008-09-06T21:58:00.012-04:00

globals.js:
- Updated the version number.
- Removed ENTER_PRESSED_IRQ constant.

shell.js
- Refactored shellHandleInput so that the parsing part is in its own routine called shellParseInput.
- Created a new "inner" class called UserCommand:


function UserCommand()
{
   // Properties
   this.command = "";
   this.args = [];
}

This is passed back from shellParseInput.
- Tested a lot to see that I didn't break anything that was previously working.

Welcome to the Fall 2008 Operating Systems blog

2008-09-06T21:05:00.005-04:00

The idea here is that we can use this blog to share ideas and techniques to enhance all of our projects. Feel free to post code too, but try and keep it to small snippets.