I think beginning with X86 is easier , and simpler for a beginner to understand; MIPS is interesting but, you will have to explain some terminologies first, e.g. pipeline, addressing modes, and others.

however, I prefer to not take much time in x86, but begin with it, then switch for MIPS as a step up , "I've given a course about Assembly language, but I faced a problem that my students were from different backgrounds , CS, ECE,......, this made me started with x86 and its assembly"

Your idea makes sense. It is easier to start with x86 ,of course and going along with MIPS later will give me an operability to introduce a more advanced approach to assembly programming.

Do you still have your course outline? It would help me out a lot so that I don't have to identify the best route and chapters to teach.

OK, I can not remember exactly , but I 'll help as I can.

1- x86 architecture

2- x86 instruction set

basic instruction and how to use it, start programming with it

3- addressing modes supported

conditional instructions (control flow ) , how to use it, modify written programs with these instructions

4- how pipelining is used to improve total execution time

starting for now I will improvise

4- present the following generations of processors, going to MIPS

5- MIPS Architecture as an up to date simple example

you can use the patterson's computer architecture book for this part

and simpler text book for the first part

That looks like a very good course outline draft.

I will build on top of these suggestions.

Thank you very much.

As you say, You would teach older version of x86's architecture to your student... I'd rather prefer an assembly language up to date with MIPS microprocessors. But, I wonder if the course close topure computing science or more electronic science oriented ? Because, on the first hand, an INTEL approach would be fruitefull. On the second hand, don'task more teach MIPS.

But it is my own opinion, only a suggestion.

Regards.

The course is more oriented towards teaching how computing is/should be done in a CPU, without looking at the electronics of the CPU, etc.

I believe that I will write a course draft for an Intel-like instruction set for the introduction and then carry on with teaching MIPS at some point.

Thank you for your suggestion. Every opinion is welcome.

I think MIPS arrchitecture is better

1. MIPS is easier to describe on FPGA and VHDL/Verilog

2. MIPS architecture is opened in MIPS single architecture

3. There are more new books and thesis for your students can read

I appreciate your answer. Thank you.

I actually did begin reading more about MIPS and am becoming more convinced that it might be a good idea to completely skip x86. To be honest, the only good thing about it is that it is simpler to understand, but I do intend to carry on with this course to a bit more advance topics, and at some point it would only slow me down and limit abilities that students will have when solving problems for homework etc.

Thanx

MIPS is a ovious choice now. In modern architecture people looking for power efficient instruction set and MIPS is very good in that. Now intel is really struggling to cope with power using x86 variant. Go for MIPS and train student with smart technology.

----

Jay

I installed MIPS architecture single cycle clock on FPGA, however I want to setup MIPS pipelined on FPGA. May any one help me what should I do?

Milan, please note that x86 architecture is based on CISC while MIPS architecture is RISC. x86 architecture offers a lot of memory addressing modes and instructions with variable length, while MIPS has very few addressing modes (because is RISC) and fixed length instructions. Also x86 has I/O separate map address (and separate I/O instructions), and MIPS has I/O memory mapped style. So your students may benefit of knowing about both architectures.

I am use that when they get to know the "harder" way where they have to think more about proper addressing and limited flexibility that x86 provides, they will latter on, when introduced to CISC instruction set architectures, be much more accustomed to using proper instruction at a proper time, whereas if I were to introduce them to x86 before MIPS, I'm afraid that they might find MIPS somewhat of a "set back" because all of a sudden they won't be able to use all sorts of addressing modes and would feel that the lack of this sort of flexibility is a bad thing, just because it is harder. I'm trying to avoid having them begin to think of RISC CPU architectures as bad in the very beginning of learning computer architecture, instruction sets and and assembly programming languages.

Thank you for joining the discussion. Every opinion is welcome, as always.

Thinh, not sure which version of MIPS (single cycle version) you installed on FPGA. In the book "Rapid Prototyping of Digital Systems, SoPC edition" by Hamblen, Tyson and Furman (http://www.springer.com/engineering/circuits+%26+systems/book/978-0-387-72670-0) you have the vhdl sources for the single cycle MIPS, but not the pipeline version. You may use older versions (preferably 1st and 2nd editions) of the book "Computer Organization and Design: The Hardware/Software Interface" by Patterson and Hennessy, (http://www.amazon.com/Computer-Organization-Design-Fourth-Architecture/dp/0123744938 for the 4th edition) which go into the details of changing from single clock cycle to multicycle and then pipeline version of the MIPS w/o going into the vhdl. If you are proficient in vhdl you can easily change the single clock cycle version of MIPS into pipeline. I did it some years ago for Altera Cyclone II on DE2 board.

Yeah, for an assembly course point of view, student may get the wrong impression that MIPS has disadvantages (not may addressing modes) but with RISC architecture is easier to implement pipeline, which overall offer better execution times than CISC. Of course for an assembly course you don't go into details of pipeline, alignment, etc.

No, I will not be using VHSIC language. I will go with a simulator for the very basics of programming CPUs. This is a beginner course.

I've found the MARS simulator for MIPS being very adequate for this course. It has some limitations, but they do not reach to the level I expect to achieve and cover with students in a single semester course.

However, for my information and future reading, these books will make it to my top priority lists. Thank you.

I think that x86 architecture assembly is better

I will look it up. It sounds interesting.

I understand some Russian (learned it and by the way my native language is a Slavic - Serbian), so it might be of help. I'd be thankful if you could point me to the publication page if it is available on the Web. Thank you.

I thought 8 bit assembly language a few years back. thinking that, the simpler (8 bit) , the better. It was perceived to be very difficult ! I moved onto MIPS next semester, and it was very CLEAN. So, I would say, definitely MIPS. x86 architecture and/or assembly offers nothing more than MIPS as far as instructive purposes. x86 is CISC, so, it is nearly impossible to explain the decoder, fetch engine, execution, etc ... My suggestion is : Use MIPS R2000 or 3000, either the book by Kane, or the Robert Britton book, and use a MIPS emulator (if I remember correctly, there was one called MARS). Also, remember, gcc has MIPS compilation. I found it very instructive to write very simple C programs, compile them with gcc, and see the assembly output. MARS emulator also had a step-by-step emulator.

I am teaching my students X86 in the Assembly course and have taught MIPS in the computer architecture course. This choice was mainly due to the fact that in "computer organization and assembly" the students need to get acquainted with the Assembly language and in the computer architecture course they need to learn more about implementation details and MIPS is a perfect choice in this regard. Using MIPS you can show them the internal working of this architecture, and the X86 doesn't at least suit for a graduate-level course because the internal working is very very complex. And also the pipelining of instructions is of prime importance in any computer Architecture course. And Assembly just focusses on how the compiler actually converts from a higher-level program to a human-level readable machine code that could be used for advanced level debugging and optimization of programs. Regards