Compiler Construction With Embedded Xinu - Revision history

Amallen: /* Potential Course Structure */

2010-08-27T19:28:07Z

Potential Course Structure

Amallen: /* Potential Course Structure */ added link to grammar

2010-08-27T19:17:50Z

Potential Course Structure: added link to grammar

Amallen: /* Potential Course Structure */ added a section about monitors

2010-07-30T00:55:50Z

Potential Course Structure: added a section about monitors

Amallen: /* Potential Course Structure */ deleted extra empty line

2010-07-28T23:03:04Z

Potential Course Structure: deleted extra empty line

Amallen: /* Potential Course Structure */ Added paragraph describing the specific additions we made to Appel and Palsberg's MiniJava language

2010-07-28T23:02:40Z

Potential Course Structure: Added paragraph describing the specific additions we made to Appel and Palsberg's MiniJava language

Amallen: /* Course Outline */ removed links to assignment pages that dont need pages

2010-07-28T21:05:14Z

Course Outline: removed links to assignment pages that dont need pages

Amallen: added link to our Concurrent MiniJava grammar

2010-07-28T20:31:54Z

added link to our Concurrent MiniJava grammar

Amallen at 20:23, 28 July 2010

2010-07-28T20:23:52Z

Amallen: first draft of the page

2010-07-28T20:03:33Z

first draft of the page

Amallen: /* Course Outcomes */

2010-07-28T19:30:24Z

Course Outcomes

@@ Line 23: / Line 23: @@
 == Potential Course Structure ==
-The course outlined below describes a compiler construction course focusing on a semester long project in which students build most of the pieces of a complete working compiler. For this example course we take the compiler project from Appel and Palsberg's [http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=052182060x Modern Compiler Implementation in Java] [[Compiler Construction With Embedded Xinu#References|[2]]] and modify it to target a MIPS platform running the Xinu operating system. We take advantage of the fact that our compiler targets a runtime with an operating system and add high-level I/O and concurrency features to Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language, creating our own [http://www.mscs.mu.edu/~brylow/cosc4400/Spring2011/ConcurrentMiniJava.html Concurrent MiniJava Grammar] language.
+The course outlined below describes a compiler construction course focusing on a semester long project in which students build most of the pieces of a complete working compiler. For this example course we take the compiler project from Appel and Palsberg's [http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=052182060x Modern Compiler Implementation in Java] [[Compiler Construction With Embedded Xinu#References|[2]]] and modify it to target a MIPS platform running the Xinu operating system. We take advantage of the fact that our compiler targets a runtime with an operating system and add high-level I/O and concurrency features to Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language, creating our own [http://www.mscs.mu.edu/~brylow/cosc4400/Spring2011/ConcurrentMiniJava.html Concurrent MiniJava] language.
 We allow Java-like threading and synchronization with our added support for class declarations inheriting the built in ''Thread'' class and with added support for Java's ''synchronized'' keyword. We also add external operating system calls for I/O operations and for operations to create and manipulate multiple threads of execution. Specifically, we add the ability to print strings with ''Xinu.print(String s)'', the ability to print a new line with ''Xinu.println()'', the ability to print an integer with ''Xinu.printint(int x)'', the ability to read in an integer input with ''Xinu.readint()'', the ability to create a thread of execution with ''Xinu.threadCreate(Thread t)'', the ability for a thread to yield control of the processor with ''Xinu.yield()'', and the ability for a thread to sleep for a given number of milliseconds with ''Xinu.sleep(int time)''.
@@ Line 29: / Line 29: @@
 The links in the outline below describe the changes necessary in each assignment to add these high-level I/O and concurrency features to the language, including the modifications for targeting a Xinu backend instead of the book's intended MIPS simulator. In addition to these compiler changes, modifications must also be made to Xinu to offer the runtime support required by the ''synchronized'' keyword. Since Java's ''synchronized'' feature depends on the JVM monitor system, which has subtly different semantics from standard O/S semaphores, [[Adding Monitors To Xinu|monitor constucts]] must be added to Xinu.
-Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our [http://www.mscs.mu.edu/~brylow/cosc4400/Spring2011/ConcurrentMiniJava.html Concurrent MiniJava Grammar] language one needs our [[Xinu Helper Class|Xinu.java]] helper class.
+Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our [http://www.mscs.mu.edu/~brylow/cosc4400/Spring2011/ConcurrentMiniJava.html Concurrent MiniJava] language one needs our [[Xinu Helper Class|Xinu.java]] helper class.
 ===== Course Outline =====

@@ Line 23: / Line 23: @@
 == Potential Course Structure ==
-The course outlined below describes a compiler construction course focusing on a semester long project in which students build most of the pieces of a complete working compiler. For this example course we take the compiler project from Appel and Palsberg's [http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=052182060x Modern Compiler Implementation in Java] [[Compiler Construction With Embedded Xinu#References|[2]]] and modify it to target a MIPS platform running the Xinu operating system. We take advantage of the fact that our compiler targets a runtime with an operating system and add high-level I/O and concurrency features to Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language, creating our own [[Concurrent MiniJava Grammar|modified MiniJava]] language.
+The course outlined below describes a compiler construction course focusing on a semester long project in which students build most of the pieces of a complete working compiler. For this example course we take the compiler project from Appel and Palsberg's [http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=052182060x Modern Compiler Implementation in Java] [[Compiler Construction With Embedded Xinu#References|[2]]] and modify it to target a MIPS platform running the Xinu operating system. We take advantage of the fact that our compiler targets a runtime with an operating system and add high-level I/O and concurrency features to Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language, creating our own [http://www.mscs.mu.edu/~brylow/cosc4400/Spring2011/ConcurrentMiniJava.html Concurrent MiniJava Grammar] language.
 We allow Java-like threading and synchronization with our added support for class declarations inheriting the built in ''Thread'' class and with added support for Java's ''synchronized'' keyword. We also add external operating system calls for I/O operations and for operations to create and manipulate multiple threads of execution. Specifically, we add the ability to print strings with ''Xinu.print(String s)'', the ability to print a new line with ''Xinu.println()'', the ability to print an integer with ''Xinu.printint(int x)'', the ability to read in an integer input with ''Xinu.readint()'', the ability to create a thread of execution with ''Xinu.threadCreate(Thread t)'', the ability for a thread to yield control of the processor with ''Xinu.yield()'', and the ability for a thread to sleep for a given number of milliseconds with ''Xinu.sleep(int time)''.
@@ Line 29: / Line 29: @@
 The links in the outline below describe the changes necessary in each assignment to add these high-level I/O and concurrency features to the language, including the modifications for targeting a Xinu backend instead of the book's intended MIPS simulator. In addition to these compiler changes, modifications must also be made to Xinu to offer the runtime support required by the ''synchronized'' keyword. Since Java's ''synchronized'' feature depends on the JVM monitor system, which has subtly different semantics from standard O/S semaphores, [[Adding Monitors To Xinu|monitor constucts]] must be added to Xinu.
-Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our [[Concurrent MiniJava Grammar|modified MiniJava]] language one needs our [[Xinu Helper Class|Xinu.java]] helper class.
+Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our [http://www.mscs.mu.edu/~brylow/cosc4400/Spring2011/ConcurrentMiniJava.html Concurrent MiniJava Grammar] language one needs our [[Xinu Helper Class|Xinu.java]] helper class.
 ===== Course Outline =====

@@ Line 27: / Line 27: @@
 We allow Java-like threading and synchronization with our added support for class declarations inheriting the built in ''Thread'' class and with added support for Java's ''synchronized'' keyword. We also add external operating system calls for I/O operations and for operations to create and manipulate multiple threads of execution. Specifically, we add the ability to print strings with ''Xinu.print(String s)'', the ability to print a new line with ''Xinu.println()'', the ability to print an integer with ''Xinu.printint(int x)'', the ability to read in an integer input with ''Xinu.readint()'', the ability to create a thread of execution with ''Xinu.threadCreate(Thread t)'', the ability for a thread to yield control of the processor with ''Xinu.yield()'', and the ability for a thread to sleep for a given number of milliseconds with ''Xinu.sleep(int time)''.
-The links in the outline below describe the changes necessary in each assignment to add these high-level I/O and concurrency features to the language, including the modifications for targeting a Xinu backend instead of the book's intended MIPS simulator.
+The links in the outline below describe the changes necessary in each assignment to add these high-level I/O and concurrency features to the language, including the modifications for targeting a Xinu backend instead of the book's intended MIPS simulator. In addition to these compiler changes, modifications must also be made to Xinu to offer the runtime support required by the ''synchronized'' keyword. Since Java's ''synchronized'' feature depends on the JVM monitor system, which has subtly different semantics from standard O/S semaphores, [[Adding Monitors To Xinu|monitor constucts]] must be added to Xinu.
 Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our [[Concurrent MiniJava Grammar|modified MiniJava]] language one needs our [[Xinu Helper Class|Xinu.java]] helper class.

← Older revision		Revision as of 23:03, 28 July 2010
Line 29:		Line 29:
	The links in the outline below describe the changes necessary in each assignment to add these high-level I/O and concurrency features to the language, including the modifications for targeting a Xinu backend instead of the book's intended MIPS simulator.		The links in the outline below describe the changes necessary in each assignment to add these high-level I/O and concurrency features to the language, including the modifications for targeting a Xinu backend instead of the book's intended MIPS simulator.

−
	Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our [[Concurrent MiniJava Grammar\|modified MiniJava]] language one needs our [[Xinu Helper Class\|Xinu.java]] helper class.		Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our [[Concurrent MiniJava Grammar\|modified MiniJava]] language one needs our [[Xinu Helper Class\|Xinu.java]] helper class.

@@ Line 23: / Line 23: @@
 == Potential Course Structure ==
-The course outlined below describes a compiler construction course focusing on a semester long project in which students build most of the pieces of a complete working compiler. For this example course we take the compiler project from Appel and Palsberg's [http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=052182060x Modern Compiler Implementation in Java] [[Compiler Construction With Embedded Xinu#References|[2]]] and modify it to target a MIPS platform running the Xinu operating system. The links in the outline below describe the changes necessary in each assignment to add high level I/O and concurrency features to the language, including the modifications for targeting a Xinu backend instead of the book's intended MIPS simulator.
+The course outlined below describes a compiler construction course focusing on a semester long project in which students build most of the pieces of a complete working compiler. For this example course we take the compiler project from Appel and Palsberg's [http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=052182060x Modern Compiler Implementation in Java] [[Compiler Construction With Embedded Xinu#References|[2]]] and modify it to target a MIPS platform running the Xinu operating system. We take advantage of the fact that our compiler targets a runtime with an operating system and add high-level I/O and concurrency features to Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language, creating our own [[Concurrent MiniJava Grammar|modified MiniJava]] language.
 Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our [[Concurrent MiniJava Grammar|modified MiniJava]] language one needs our [[Xinu Helper Class|Xinu.java]] helper class.

@@ Line 35: / Line 35: @@
 | 02 || || || Lexical Analysis, Automata || || || || [[Assignment: Scanner|Project 2: Scanner]]
 |-
-| 03 || || || Syntax Analysis, Grammars || || || || [[Assignment: Automata and Grammars|Homework 1: Automata and Grammars]]
+| 03 || || || Syntax Analysis, Grammars || || || || Homework 1: Automata and Grammars
 |-
 | 04 || || || Parser Generators || || || || [[Assignment: Parser|Project 3: Parser]]
@@ Line 49: / Line 49: @@
 | 09 || || || Basic Blocks || || || || [[Assignment: Translation|Project 5: Translation]]
 |-
-| 10 || || || Instruction Selection || || || || [[Assignment: Activation Records| Homework 2: Activation Records]]
+| 10 || || || Instruction Selection || || || || Homework 2: Activation Records
 |-
 | 11 || || ||Liveness Analysis ||
@@ Line 59: / Line 59: @@
 | 14 || || || Advanced Topics ||
 |-
-| 15 || || || Advanced Topics || || || || [[Assignment: Register Allocation|Homework 3: Register Allocation]]
+| 15 || || || Advanced Topics || || || || Homework 3: Register Allocation
 |}

@@ Line 25: / Line 25: @@
 The course outlined below describes a compiler construction course focusing on a semester long project in which students build most of the pieces of a complete working compiler. For this example course we take the compiler project from Appel and Palsberg's [http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=052182060x Modern Compiler Implementation in Java] [[Compiler Construction With Embedded Xinu#References|[2]]] and modify it to target a MIPS platform running the Xinu operating system. The links in the outline below describe the changes necessary in each assignment to add high level I/O and concurrency features to the language, including the modifications for targeting a Xinu backend instead of the book's intended MIPS simulator.
-Appel and Palsberg's MiniJava language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our modified MiniJava language one needs our [[Xinu Helper Class|Xinu.java]] helper class.
+Appel and Palsberg's [http://www.cambridge.org/resources/052182060X/ MiniJava] language is a subset of the standard Java language, and this means test cases written in MiniJava can be compiled and run using standard Java compilers. To use standard Java compilers to compile programs written in our modified MiniJava language one needs our [[Xinu Helper Class|Xinu.java]] helper class.
 ===== Course Outline =====

@@ Line 6: / Line 6: @@
 Including Embedded Xinu in a compiler construction course allows students to explore the compilation of high level language constructs that rely on interacting with the underlying runtime. Many traditional compilers courses simply target a processor or simulator, but by targeting a ''platform'' (a processor and operating system combination) one can extend the source language to include more advanced language features such as I/O operations and thread creation, manipulation, and concurrency. This also allows students to run their test cases on real hardware and see these programs actually interacting with a real runtime. In modern programming these high level language features are vital, and it is important for students to see what the processor and runtime are doing when they use these features in their own programs.
 == Course Outcomes ==
-Course development can parallel learning objectives and topics associated with many Programming Language Translation or Compiler Construction courses. [[Compiler Construction With Embedded Xinu#References|[1]]] However, by targeting a platform students can also focus on learning how compilers interact with the runtime to achieve thread concurrency and synchronization; topics which many traditional compilers courses avoid. [[Compiler Construction With Embedded Xinu#References|[2, 3, 4]]]
+Course development can parallel learning objectives and topics associated with many Programming Language Translation or Compiler Construction courses. [[Compiler Construction With Embedded Xinu#References|[1]]] However, by targeting a platform with an operating system students can also focus on learning how compilers interact with the runtime to achieve thread concurrency and synchronization; topics which many traditional compilers courses avoid. [[Compiler Construction With Embedded Xinu#References|[2, 3, 4]]]
 === Topics ===
@@ Line 20: / Line 20: @@
 * Explain the major steps involved in compiling a high-level programming language down to a low-level target machine language.
 * Construct and use the major components of a modern compiler.
 * Work together effectively in teams on a substantial software implementation project.
 == Potential Course Structure ==