Although simulators are widely used in Computer Architecture courses [2], [3], .... create effective online learning communities [2]; to participate actively in the.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
Use of Constructivism and Collaborative Teaching in an ILP Processors Course L. Moreno, C. González, I. Castilla, E.J. González, J. Sigut
Abstract—Simulators are widely used to teach Instruction Level Parallelism (ILP) topics. A simulator called SIMDE, which combines the Superscalar and VLIW approaches to ILP processors in a single environment, has been developed. SIMDE has been validated and improved using feedback from students during two academic years. Although the simulator is a valuable tool in and of itself, this proposal goes one step beyond by using it together with an educational methodology based on constructivism and collaborative learning. This methodology has been applied in a Computer Architecture course that uses the Moodle platform as a framework for collaboration between students and teachers.
I. INTRODUCTION Computer Architecture is a basic subject in a Computer Engineering curriculum. This subject is structured around three main topics at La Laguna University: 1. Memory hierarchy. 2. Internal structure of the processor. 3. Interconnection networks for multiprocessor/multicomputer. Before students have to deal with Computer Architecture, they have already been introduced to topics 1 and 3 in other subjects such as Computer Structure, Operating Systems and Communication Networks. However, the student’s knowledge of topic 2 is limited to the Von Neumann classical structure, i.e. an instruction can only start its execution whenever the previous one has been completely executed. For this reason, topic 2 starts with an explanation of pipelined
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
processors. This introduces the students to a new situation where several instructions are executed in parallel. Instruction Level Parallelism (ILP) [1] is the fundamental component of this part of the Computer Architecture course. Processors based on this architecture have to take care of all kind of hazards: structural, data and control. Several new strategies have to be introduced in order to avoid these hazards, such as parallel execution of instructions, out-of-order execution, branch prediction and some software techniques. These characteristics result in an internal structure consisting in a wide variety of components such as several levels of cache, many functional units, reservation stations, reorder buffer, Translation Lookaside Buffer (TLB), etc. As a consequence, the students need to handle many parameters in order to understand the internal structure of ILP processors. The students mainly deal with two types of ILP processors: Superscalar and Very Long Instruction Word (VLIW) / Explicitly Parallel Instruction Computing (EPIC). Superscalar
processors
dynamically
schedule
their
instructions,
whereas
VLIW/EPIC processors use static instruction scheduling. The students tend to think of static scheduling as an easy task because the techniques used for this purpose look simple. However, when they are tested on this material, they realize how difficult it may become. Knowledge construction of the students in order to understand both types of processors is difficult. In order to make this task easier a dual superscalar-VLIW simulator called SIMDE was designed. This simulator allows the students to handle the details of the superscalar hardware structure and track the dynamic instruction
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
scheduling; as well as to understand the different software techniques used in the static scheduling processors (VLIW/EPIC). Although simulators are widely used in Computer Architecture courses [2], [3], simulators by themselves are not enough to significantly improve the learning process. It is necessary to carry out other activities which allow the students to gain knowledge, comprehend theoretical concepts and apply those concepts to the real world [4], [5]. For this reason, a methodology which incorporates activities in an elearning platform (Moodle [6]) has been proposed. These activities allow collaborative work and are more easily adapted to the learning skills of the students. Face to face relations as well as both intergroup and intragroup work have been also included. This paper is organized in the following way. Section II describes the educational theories and tools that support constructivism and a collaborative environment. Section III explains the proposed collaborative environment and the activities organized in phases. The exercises proposed with the SIMDE simulator are detailed in section IV. The feedback of students obtained in the validation phase is reported in section V. Finally some conclusions are offered. II.
EDUCATIONAL FRAMEWORK: A CONSTRUCTIVIST AND COLLABORATIVE ENVIRONMENT This section describes the theoretical framework of this work and the technological tools used to implement the collaborative environment. A. Theoretical framework In order to correctly and effectively use technology in education it must be supported by proven pedagogical theories. This is why a methodology to teach
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
Computer Architecture which combines theoretical and practical procedures based on CSCL (Computer Supported Collaborative Learning) [7] - [15] and constructional learning [16] - [19] was proposed. Constructivism places more emphasis on learning contexts as an alternative to memorization. This generally involves discussion groups and building knowledge through activities closer to the real world [20]. Constructivist authors believe that practical real world situations are meaningful learning contexts [21]. Learning environments must be flexible so that the same knowledge can be represented in different ways. This allows students to learn through a variety of proposals [22]. Constructivist authors believe that computers should not be used merely to disseminate knowledge, but rather they should be used as a support tool that helps students to experience and build knowledge [23]. Martí [24] proposes applying Papert’s methods to specific constructivist educational situations and also as a way to mediate learning through computers and people. According to him, it is possible for students to acquire broad outlines of knowledge through individual exploration, but it is much more difficult for them to learn specific ideas in this way. He believes that it is necessary to base educational situations on the previous ideas of the students and that it is also vital to define how both teachers and students will intervene in this situation. Constructivism also proposes “communitarian or collaborative learning”. The idea is to encourage students to help each other, thereby reinforcing the social dimension of education [25]. This humanistic method establishes that the best results are obtained through activity and experience.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
In addition, a computer is used as mediation in these environments. This is the basis for the above mentioned CSCL methodology. CSCL focuses on how collaborative learning supported by technology can enhance peer to peer interaction and group work; it also emphasizes that sharing and distributing knowledge and expertise among community members is facilitated by collaboration and technology [26]. Thus, computer resources act as mediators. From the CSCL view, the student is an active agent in the building of his own learning process. In the CSCL methodology the student takes an active part in building his or her own learning process. CSCL has been successfully applied to teaching in the Computer Architecture area and in the design of several software environments such as Delfos, Synergo, etc., have been developed [27] - [31]. Finally, Chickering and Gamson [32] summarize the seven principles [33] for good practice in undergraduate education which should be covered as much as possible in every learning process. Good practice in undergraduate education: 1. Encourages contact between students and faculty 2. Develops reciprocity and cooperation among students 3. Encourages active learning 4. Gives prompt feedback 5. Emphasizes time on task 6. Communicates high expectations 7. Respects diverse talents and ways of learning. From this point forward the principles are referred to by their corresponding number.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
B. Technological resources As mentioned earlier, two tools were used: the Moodle platform [6] as a collaboration framework among the students and teachers and a free Instruction Level Parallelism (ILP) processor simulator called SIMDE. The simulator promotes experience and helps the students to understand superscalar and VLIW processors’ concepts. Both tools are analyzed in the following subsections. 1) Moodle’s Features: Moodle is a Course Management System (CMS) which has been designed using sound pedagogical principles. This free software package helps educators to create effective online learning communities [2]; to participate actively in the learning process; and to collaborate in groups. It is well known that collaborative activities often promote metacognitive processes such as reflection, selfexplanation and self-regulation. This platform manages contents, students and teachers and offers a large variety of resources and activities, such as quizzes, consultations, diaries, workshops, SCORM (Sharable Content Object Reference Model) objects, among others. Moreover, one of the activities included in Moodle, the Wiki [34], was conceived as a collaborative process. Wiki is a software application that facilitates the collective creation of web documents using a simple system of labels and tags. The content can also be published on the internet without the need for revision or approval. This platform increases the student-faculty contact time (principle 1 in the Chickering and Gamson list) since a student is in contact with their peers for more time using both asynchronous (forums) and synchronous (chat rooms) tools. Moreover, it encourages collaborative work among students (principle 2) allowing
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
the sharing of ideas and research results. Principle 3 is also promoted by Moodle. Studies have shown that students only remember 20% of what they listen to but 90% of what they talk about and make [35]. Furthermore, the students can schedule their learning time (principle 5) since the web platform is available 24 hours a day/7 days a week. Principle 7 is reached because the collaborative work in the platform offers the students the possibility of showing their talents as well as learning from the others. Although principles 4 and 6 are not directly offered by the Moodle platform, it does serve as a basis for them. The Moodle provides selfevaluation tools that can be managed by the professor. It can also be a framework where the students can download high quality materials which are usually prepared by the professor. Both principles have been included in the designed approach. The platform offers a discussion framework where the students can put the finishing touches on the meaning negotiation process started in the class using the forums and wiki services. The students can also implement new activities related to the ILP concepts or repeat the same activities developed in class. In this sense, the advantages of designed activities may be increased in this virtual environment. 2) Contribution of SIMDE Simulators are commonly used in Computer Architecture and Organization courses to bridge the gap between theoretical knowledge and practical experience [36], [37]. Although simulators offer simplified versions of the real world, developers should
not
oversimplify their design
because
this could lead
to
new
misconceptions. A variety of simulators have been used for educational purposes in every field of Computer Architecture: cache (Dinero [38]), RISC (WinMIPS64 [39]), vector processors (DLXVSim [40]), superscalar (MIDAS, SATSim [41] and
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
SimpleScalar [42]), VLIW (TMS320C6xxx [43]), etc. Some of these simulators can be used for ILP teaching because of their interesting characteristics: WinMIPS64 is an instruction set simulator designed as a replacement for the popular Microsoft Windows utility WinDLX. The main reason why it is so useful to clarify the pipeline concept is because of its friendly user interface. MIDAS was an attractive MIPS R10000 simulator, but it is not currently available. It has a simple and attractive graphical interface displaying a R10000 block diagram that allows the user to track the instructions. The only available version of this program is an early beta that contains several critical bugs and there is no further support from the authors. SATSim is an interactive animation tool which conveys superscalar architecture concepts. In our opinion, its main disadvantages are its input format in the form of complicated trace files that are not easily generated by students and a confusing GUI. SimpleScalar is a really comprehensive processor simulator which is very useful for any researcher in Computer Architecture. It includes many tools and benchmarks. Examples of commercial VLIW simulators are those developed for the TMS320C6x DSP processors. Commercial programs such as these are highly specialized, making it difficult for them to be a valuable teaching tool. However, in this particular case, the simulator could be alternatively used as a revision tool.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
In spite of the advantages of some of these simulators, there are two main reasons why a new simulator was designed specifically for this proposal. Firstly, there is a lack of educational VLIW simulators and secondly, it is desirable to provide the students with an integrated learning environment which facilitates a deeper knowledge about ILP (both the VLIW and the superscalar) concepts. SimpleScalar would have made a good basis for the design because it supports the modification of the instruction set and several machine characteristics. Unfortunately, adapting this tool so that a VLIW processor could also be incorporated would have been a difficult task involving several changes to the GNU compiler and assembler, which the author of Simplescalar himself describes as “very painful” [44]. In conclusion, the aim of this work is to provide students with a two-in-one (superscalar and VLIW) simulator which is not intended as an exhaustive and extremely detailed tool, but as an educational instrument which allows a better comprehension and handling of basic ILP concepts. For this reason some characteristics of the above named simulators have been skipped in the proposed design in order to emphasize its educational purpose. 3) Description of SIMDE SIMDE allows the students to deal with both Superscalar and VLIW processors. This combined approach requires considerable effort in the definition of a common TABLE I
structure for both processor types. The basic components of this structure can be COMMON COMPONENTS Component
Notes
TABLE II seen in Table I.Purpose Sixty-four 32-bit General GPRs for C integer operations. SUPERSCALAR OMPONENTS Registers (GPRs) Component Notes A common instruction set has been used as aFPRs basis bothpoint theoperations. superscalar and Floating Point Registers Sixty-four 32-bit single precision for for floating Prefetch Unit Loads and predecodes the instructions from the instruction cache in a (FPRs) transparent way for the rest of the hardware.
the VLIW codes. A generic MIPS IV-like instruction subset repertoire has been Memory Main memory: 1024 32-bit words. Decoder Checks instructions for true data dependences (due to RAW hazards) Instruction cache: no cache misses (for simplification purposes). Programs Reservation Stations (REs) (both Issue the instructions. One RE are per completely type of FU.allocated on it. sequential and VLIW code) Reorder Buffer (ROB) Supports speculative execution and register Allows the Data cache: allows a user-defined proportion of cache renaming. misses. instructions to commit in-order. Functional Units (FUs) Six specific pipelined FUs: integer adder, integer multiplier, floating adder, memory and branch. strategy. Each type of FU has a specific Branch Prediction Table floating Uses amultiplier, 2-bit dynamic branch prediction number one-cycle pipeline (also called FU latency). (extra) Address FUs Split of memory access just asstages Tomasulo’s algorithm does.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
defined, including arithmetic instructions (ADD, ADDI, SUB, MULT…), bit instructions (OR, AND, XOR…), shift instructions (SLLV, SRLV), floating point instructions (ADDF, MULTF…), load/store instructions (LW, SF…) and branch instructions (BNE, BGT…). The superscalar processor is based on Tomasulo’s algorithm [45]. Users can modify the issue rate from 2 to 16 instructions per clock. The designed processor implements multiple issue, branch prediction and speculation. The main components of this processor can be seen in Table II. In contrast to the superscalar approach, hardware simplicity is the main goal in VLIW processor design. Only a few structures (see Table III) have been added to the common hardware base in order to characterize VLIW processors. TABLE III VLIW COMPONENTS Component
Notes
Predicate registers
Sixty-four 1-bit registers for predication (Full-predication scheme) support. Multiway branching is supported too.
NaT bits
Each GPR and FPR has an extra NaT (Not a Thing) bit. NaT bits are used to handle cache misses.
The designed VLIW processor issues one long instruction per cycle. The format of long instructions consists of as many single instructions (called operations in this context) as defined FUs. Branch operations are limited to one per instruction in order to simplify the design. SIMDE supports a grid-based graphic interface that allows a clearer presentation of contents and a more intuitive interaction between the students and the processor components. The practical experience is reinforced with contextual help easily accessible from any part of the simulator. This help includes a user guide for
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
the simulator and a quick review of the theoretical concepts that the students may need. Sequential codes can be easily created by using any plain text editor such as Windows Notepad. The obtained codes can be either simulated on the superscalar processor or used as a basis for a VLIW code. The users can tune several parameters of the simulator such as: Data cache miss probability. Number of FUs of each type. Latency of FUs of each type (number of pipeline stages). Maximum instruction issue rate (only Superscalar processor). Other simulator features are shown in Table IV. TABLE IV SOME SIMDE FEATURES Feature Customization of the execution window by hiding or showing components. Contents of memory and registers can be modified before and during simulations. They can also be loaded/saved from/to a file. Continuous and step-by-step execution. Breakpoints can also be used. VLIW codes can be created from scratch (based on a sequential code). Furthermore, they can be saved/loaded to/from a file. An easy code scheduling mechanism that is used by dragging the operations from the sequential code panel and dropping them on an appropriate long instruction cell. Operations and long instruction words can be added and deleted by the user. Predication can be applied to any operation by simply double-clicking on it. Branches are completely customizable: target, predicate registers, among others. The area of influence of an operation (i.e. the amount of long instructions where a truedependent operation should not be scheduled) can be coloured in order to help the students avoid true dependencies. A self-checking tool ensures that the code is correct. Each instruction in the ROB can be coloured in order to track it along its execution flow.
Processor Both Both Both VLIW VLIW VLIW VLIW VLIW VLIW
VLIW Superscalar
SIMDE is freely available for academic use and can be downloaded from Internet [46], thereby covering Chickering and Gamson’s principles 5 and 7. Section III deals with more principles covered by SIMDE.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
III.
CONSTRUCTIVISM AND DESCRIPTION OF THE COLLABORATIVE SCENARIO This section describes the way the work is structured and how the constructivist and collaborative approaches are applied to this methodological proposal. A. Active Learning Knowledge can be constructed through different activities including negotiation, mediation and experimentation. The students participate in various debates moderated by the professor which negotiate the meaning of ILP architecture concepts. These debates generally uncover various misconceptions which can then be analyzed and refuted. A common misconception is that the effects of every processed instruction cannot be reversed, in other words, that every instruction which enters into the processor is always executed. In addition, students are given several self-evaluation tests about specific concepts shown in the procedures. Afterward, the correct answer to every question is explained in detail, thereby satisfying Chickering and Gamson’s fourth principle, “prompt feedback”. B. Creation of a Learning Context Materials and pedagogical tools by themselves do not guarantee knowledge construction. It is necessary to create an environment which allows social interaction, an adequate use of media and experimentation. For this reason, several actions are carried out: The students are distributed among several discussion groups. Each of these groups deals with a different state of the art commercial computer architecture such as ITANIUM, HP PA-RISC 8000, Emotion Engine (PS2), AMD 64:
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
OPTERON, Hitachi SH-4 (Dreamcast), Sun UltraSPARC III, MIPS R12000, Centrino, SGI Origin 2000 and 3000, Hyperthreading Intel Xeon, SG Oring 2000 and 3000, IBM G3 - G5 and Alpha 21264. The students carry out a sort of peer review (covering Chickering and Gamson’s fourth principle) by comparing their results with the ones obtained with similar architectures by other groups. Moreover, the students are encouraged to cooperate in the generation of a high-quality document that will be used by students in future courses, thus satisfying the sixth principle on Chickering and Gamson’s list. The individual and group work is carried out in an open learning environment, where the Moodle e-learning platform and the use of SIMDE allow the learning process to be adapted to different student learning methods and used anywhere, as stated in principle 7. Professors mediate the learning process. They create guidelines on how to generate the documents that the students present in class and the exercises developed in the simulator. They answer the student’s questions and formulate some questions of their own that help the students to gain a deeper knowledge about the topics. C. Collaborative Learning Collaborative learning is reached through intergroup and intragroup interactions consisting of discussion, reflection and decision making using both the e-learning platform and the class. The five collaborative elements are applied as follows [47]: Positive interdependence. This is the core element. The students need each other in order to complete the group's task successfully - they "sink or swim"
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
together. This experience allows the professors to emphasize the responsibility of students both as individuals and groups. It also encourages discussion among groups. Face to face interaction. If the group wants to complete its task, the students need face to face interaction with the rest of the members. By doing so, they have to work together by sharing resources and helping each other. Individual accountability. Individual accountability is reached by assigning a different profile to each member of the group. For example, the roles proposed in the SIMDE procedure set are chosen according to the optimization strategies that are used in the different problems to be solved, i.e. dot product, DAXPY and linked lists or vectors. Each group chooses one of these problems and applies different optimization techniques. Each member of the group is responsible for the application of at least one strategy. Interpersonal and small group skills. Social skills are essential for effective collaboration. Students should get involved in the assigned task and the team work simultaneously. In the proposed set of procedures, these skills are stimulated through the creation of teams with common interests and the promotion of their identity as a group. Group processing. Finally, the evaluation of the group processing is carried out by individual students, other members of the group and other groups. The documents generated by the groups are presented in class and published on the course web page. Thus, the students revise the task and identify, with the help of the professor and their peers, their weak points as well as their main
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
Task
TABLE V TASKS Interaction I G OG P X X X X X X
1. Theoretical Lessons 2. Practical Lessons 3. Selected exercise 4. Discussion SIMDE 5. Analysis of state of the art commercial machines 6. Presentation about state of the art commercial machines 7. WIKI of ILP concepts about state of the art machines 8. WIKI analysis 9. Final evaluation
X
X
X
X
X
X
X
X
X X
X X
X
Duration 6 hours all groups 6 hours all groups 6 hours/group 1 hour/group 15 hours/group 1 hour/group 2 hours all groups
X
X
2 hours all groups
Interaction is defined as follows: I: individual, G: intragroup, OG: intergroups, P: professor.
contributions. For this exchange of information, the students should use the elearning platform, in particular a chat room and a forum, specially created for this activity. In order to understand the collaborative part of the proposed procedure, Table V presents the list of tasks carried out by the professor and the students.
1) Theoretical lessons All the concepts related to superscalar and VLIW processors are presented to the students in a few theoretical lessons. Furthermore, they are encouraged to read about ILP processors from [1] and [48]. 2) Practical lessons The students are provided with SIMDE in order to familiarize themselves with the simulator environment and its features. This task is further explained in section IV. 3) Selected exercise The groups of students also use SIMDE to solve a comprehensive problem. This exercise is further explained in section IV and it covers the following collaborative topics:
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
- Discovery learning. - Experimentation. - Simulator as mediator. - Contact with powerful ideas as objects to extrapolation and appropriation. 4) SIMDE discussion Each group explains its proposals and conclusions for the selected exercise to the professor. This achieves a social construction of knowledge through teacherlearner / learner-teacher interactions. 5) Analysis of state of the art commercial machines This objective-guided search encourages the students to make use of WebQuest [49] and classic bibliography searching. The students look for information about their assigned processor architecture for a week in journals like IEEE Micro and on the Internet. With this information, they prepare a brief PowerPoint-like presentation of about 30-40 minutes. This task involves social construction of knowledge through intergroup and intragroup interactions and discovery learning. 6) Presentation on state of the art commercial machines Each group gives a presentation on its assigned machine in class. After the presentation, they carry out a discussion with other groups that have been assigned similar processors in order to compare their results. Thus, they contact with powerful ideas as objects to extrapolation and appropriation. 7) WIKI of ILP concepts about state of the art machines Each group produces a collaborative document about
concepts
and
characteristics of the analyzed machines. This helps them to consolidate their learning by means of the transference and synthesis of the studied concepts. Moreover, students of successive years will make use of these documents by correcting their weaknesses and profiting from their valuable contents.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
8) WIKI analysis The teachers point out common points and differences among the analyzed machines. Additionally they mediate in several discussions about these topics. In this
way
analysis,
thoughts
and
learning
about
possible
mistakes
or
misconceptions are achieved. 9) Final evaluation This mixed evaluation method includes observation, automatic registration, interview, individual test, teacher notebook, etc. The following methods are used in this task: - Quantitative Methods (individual tests, automatic registers in Moodle) - Qualitative Methods (observations, interviews) - Social Networks (observation of face to face relations, interactions in Moodle)
As can be observed from this methodological approach, the role of SIMDE as learning mediator is essential in order to improve an educational experience that covers all ILP processor concepts. The next section explains the pedagogical activities carried out using this tool. IV. IMPROVING THE EDUCATIONAL EXPERIENCE THROUGH SIMDE The work proposed with SIMDE consists of three two-hour practical sessions in class and a group exercise. The contents of each session and the group exercise are described in the following subsections. A. Superscalar Example The objectives of the first session are as follows:
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
To familiarize the students with the simulator environment and its basic functionalities. To consolidate the students’ knowledge about superscalar processors. This session is focused on clarifying how Tomasulo’s algorithm works and the way the instructions flow through the superscalar components such as ROB, reservation stations, functional units, etc. Hence, it is essential to first explain all of these topics in theoretical sessions. To begin with, a simple sequential code that represents a single loop example is loaded (see example 1). This code adds a constant to each component from a 16element array. The result is placed in another array. Example 1: Sample code (loop.pla)
LOOP:
DADDUI R2 R0 #50 DADDUI R3 R0 #70 DADDUI R4 R0 #40 LF F0 (R4) DADDUI R5 R2 #16 LF F1 (R2) ADDF F1 F1 F0 SF F1 (R3) DADDUI R2 R2 #1 DADDUI R3 R3 #1 BNE R2 R5 LOOP
This example requires the students to appropriately fill the memory before they start the simulation by putting a constant value at memory address 40, and 16 floating point values at memory addresses from 50 to 65. The buttons on the execution toolbar allow the users to control the simulator. The students can start, pause, stop and restart the simulation, as well as check the amount of clock cycles since booting. The superscalar execution window shows all of the processor components: ROB, reservation stations, functional units, etc., in a way that the instruction flow is remarked as indicated in Fig. 1. The students can
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
Fig. 1. Superscalar execution.
even highlight instructions using colors to track them easily through their execution cycle. This helps to clarify some obscure details about Tomasulo’s algorithm. The students can check the clock (on the execution toolbar) after each experiment to verify on their own the importance of the branch miss predictions or the influence of cache misses on the execution performance. The issue rate or the number and latency of FUs are other parameters that can be customized by the students. These parameters can be modified to extract conclusions about the design of a superscalar processor, but the teacher should emphasize the cost of adding new FUs. At the end of this session the students are encouraged to write their own sequential codes and test them over different superscalar configurations.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
B. VLIW Example This second session is focused on the VLIW processor. Before the session can be started, students are required to have some background on the hardware resources and the software techniques related to VLIW processors. A VLIW code can be created from scratch (based on a sequential code) or a prewritten code can be loaded and then customized by the students. At this stage, it is advisable for the students to start by loading a pre-written code. Thus, the loop.vliw file can be used together with the loop.pla example seen in the previous session. When this sample code is loaded, the VLIW code window is shown. The VLIW code window is a table where columns represent the different FUs and rows represent the execution-ordered long instructions. The numbers in the cells correspond with the identifiers of the sequential instructions. The code can be modified by the students either by deleting any long instruction or operation or by adding a new one. The students can also set a predicate register for each operation or modify any branch operation behavior (branch target and predication). The students should notice that the instruction memory allocated for this code is much bigger than the corresponding sequential one. Since the long instruction word provides a field for each available FU and not all of the fields are used, there is a lot of wasted memory space. The execution of the proposed example on the VLIW processor allows the teacher to comment on the simplicity of its hardware. The VLIW execution window is much simpler than the superscalar one. It only consists of the FUs, the predicate registers and the NaT bits as shown in Fig. 2.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
TABLE VI COMPARED PERFORMANCE OF LOOP UNROLLING Iterations unrolled Clock (superscalar) Clock (VLIW) 1 (single) 72 212 2 68 108 4 61 60 Fig. 2. VLIW 43 execution. 8 36
The corresponding example executes in 212 clock cycles, in contrast to the 72 clock cycles obtained using the superscalar processor. Since the original sequential code consists of a few operations, it is not possible to obtain any performance improvement by changing the number of FUs in the processor parameters. At this point, the students should be encouraged to think about this low performance in order to include Chickering and Gamson’s principle 3. The logical consequence must be that no more ILPs can be obtained from this sequential code. Then, the teacher can propose that the students rewrite the sequential code by applying loop unrolling, software pipelining and other software techniques for
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
code optimization, giving prompt feedback as proposed in Chickering and Gamson’s principle 4. The rest of the session is focused on a two-step methodology. The students apply optimizations to the sequential code (loop unrolling, software pipelining, instructions reordering, etc.); and schedule the sequential operations over the long instruction words. Loop unrolling can be used to illustrate the influence of code optimizations on the VLIW processor performance, as seen in Table VI. Finally, the possibility of changing the VLIW structure by adding new FUs is introduced as a way to improve the performance of the unrolled codes (i.e. the eight-unrolled iterations example executes in 30 clock cycles by using 8 floating point adders and 8 memory units). The teacher can emphasize how much cheaper it is to add a new FU to a VLIW processor than a superscalar one. C. Advanced features of the VLIW simulator The objectives of the last session can be summarized as follows: 1) To remind the students of all the simulator features seen in the former sessions. 2) To use advanced features such as predication. Example 2 shows a code fragment that loads two floating point values from memory. The value in the register R32 indicates one of three possible values to be placed on a memory location: the first loaded value, the second loaded value or both values.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
Example 2: Sequential code for illustrating predication
A:
B: FIN:
DADDUI R10 R0 #10 DADDUI R1 R0 #0 DADDUI R2 R0 #1 LF F1 0(R10) LF F2 1(R10) BNE R32 R1 A ADDF F3 F1 F0 BEQ R0 R0 FIN BNE R32 R2 B ADDF F3 F2 F0 BEQ R0 R0 FIN ADDF F3 F2 F1 SF F3 2(R10)
This code scheduling requires the students to apply predication. A deeper knowledge of the simulator is needed to build an optimized code. At this point some aspects must be considered such as operation latencies and how the simulator handles predication. This code has been scheduled by assuming twocycle latency for branch operations. Regarding predication, any operation that reaches the top of a FU pipeline with a false predicate is cancelled. The simulator design ensures that branches are solved at the beginning of the cycle, whereas the evaluation of predicates is left as a final stage. D. Selected Exercise Each group of students is provided with a sufficiently complex sequential code. These codes include well-known algorithms such as the dot product or DAXPY, and a few codes that operate with linked lists or vectors. The exercise consists of: 1) Studying the sequential code. The students must look for inputs that produce the worst and best cases.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
2) Simulating this code on the superscalar processor. The students should test different inputs and different processor parameters in order to obtain the best performance. 3) Applying software techniques for code optimization over the sequential code. 4) Scheduling and simulating each of the optimized codes on the VLIW processor. Again, it is interesting to test different inputs and processor parameters. 5) Comparing results. The results from both processors must be compared and conclusions about performance should be extracted. The students should also weigh the relative costs of the processor design and the effort they invested in playing the role of compiler for the VLIW processor. Once the students have finished, all their conclusions and results are gathered into a report. V. FEEDBACK FROM THE STUDENTS Feedback from students is a crucial piece of information in order to verify the usefulness of the proposed exercises [50]. Some weaknesses and potential improvements of the simulator and the methodological proposal can also be identified in this way. The simulator was introduced to about 25 students in their last year of a Computer Engineering degree from the University of La Laguna two years ago. During the first year, the simulator was only used to reinforce theoretical lessons. The students had to test the tool at their own discretion in order to fill out a questionnaire. This questionnaire basically focused on three main aspects: 1) The suitability of the simulator for the educational requirements of the students.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
2) The features and functionality of the software. 3) The technical aspects of the simulator, such as malfunctions or bugs. The results of this first year allowed most of the bugs that had been detected to be fixed and for several improvements to be added to the simulator. Furthermore, the use of SIMDE helped the students to better understand the ILP theoretical concepts, as seen in fig. 3.
81%
6%
13%
I strongly agree
I agree
I disagree
Fig. 3. Students’ answers to the question: “Does SIMDE help to understand theoretical concepts?”
As a complement to the validation tasks, the simulator was presented in a domestic educational conference [51] and more opinions and suggestions were collected from several users that tested the simulator. The simulator improved the learning experience of the students by itself. However, well-known educational theories were also applied to the methodological proposal described in this paper. This methodology was applied to about 40 new students the second year.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
One of the most relevant effects of the application of this methodology was a better understanding of both processors (see fig. 4a and 4b). However, the most remarkable results were related to the student-teacher interaction. The students showed a higher level of motivation, which was reflected in a significant increase in class participation and general interest in the subject. Consequently, the teachers obtained a great amount of valuable information about their students. 2004-2005
2003-2004 45%
12% 3%
72% 0%
11%
16%
41%
I strongly agree I disagree
I agree I strongly disagree
Fig. 4a. Answers of first year students to the question: “Is it easy to understand the contents of the processor?”
I strongly agree I disagree
I agree I strongly disagree
Fig. 4b. Answers of second year students’ to the question: “Is it easy to understand the contents of the processor?”
Finally, Table VII shows the evolution of the students’ grades during the last three years. These results corroborate the positive effects of applying these educational tools in a Computer Architecture course. The first year, when the simulator had not yet been used, a considerable number of students failed the course (F). The evaluation was based on an exam and several laboratory practices. The second year, the number of failures was drastically reduced, but the number of high grades (A or B) did not meaningfully change. The exam continued being the main evaluation method. The third year, the methodological proposal described in this paper was introduced in an effort to further improve student performance. After the addition of the new methodology the number of students who failed the course became negligible and those that earned either an A or a B
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
rose substantially. The exam was still used, but the teachers had a considerable amount of extra information about their students thanks to the new methodological proposal. This extra information helped the teachers to better evaluate the students’ work. VI. CONCLUSIONS AND FUTURE WORK A constructivist and collaborative methodological approach to teaching ILP Architectures has been presented. The aim of this approach is to improve the learning process. The described methodology has been tested by students finishing the last year of a Computer Engineering degree in the University of La Laguna. The key aspects of the approach follow the principles of constructivist and TABLE VII EVOLUTION OF STUDENTS’ GRADES Grades 2002-2003 2003-2004 2004-2005 (Without (With (Method. simulator) simulator) proposal) F 27.59% 4.35% 0.00% CDE 41.38% 65.22% 41.03% AB 31.03% 30.43% 58.97% Results are referred to June qualifications.
collaborative
pedagogical
theories.
This
approach
is
supported
by
two
technological tools: Moodle, an e-learning platform, and a simulator of ILP architectures called SIMDE, developed specifically for this course. A collaborative virtual learning environment, which includes this simulator and other learning resources, has been designed and developed. The e-learning platform was selected because it satisfies the theoretical principles, allows efficient communication among students and teachers, and offers a wide diversity of resources and activities.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
A simulation tool of ILP architectures that covers dynamic (using a superscalar processor) and static scheduling (using a VLIW processor) has been specially designed and incorporated into the teaching strategy. The simulator is a valuable tool for teaching ILP Architectures that offers advantages that no other available simulators can provide. The main advantage of the simulator is that it allows students to compare static scheduling versus dynamic scheduling using the same basic structure, components and instruction set. The numerous tests which have been performed during the last two years have confirmed the utility of SIMDE as an educational tool to support teaching of ILP Architectures. The first year the focus was on the technical validation of the tool, but last year a complete procedure set that improves the educational experience of the students was designed. Regarding the learning experience with the proposed methodology, the students have shown a deeper knowledge as well as greater motivation, difficult to find in these types of courses. Currently new features are being developed for the simulator, including more branch prediction schemes and a trace cache. In addition, the instruction set is being increased so that the students can design more example codes illustrating the functionalities of ILP Architectures. Due to the great interest and the positive results, this methodological proposal will also be applied to teaching other aspects of the course, such as memory hierarchy and multiprocessing.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
REFERENCES [1] J. L. Hennesy and D. A. Patterson, Computer Architecture: A Quantitative Approach. 3rd ed., San Mateo, CA: Morgan Kaufmann, 2003. [2] V.S. Pai, P. Ranganathan, and S.V. Adve, “RSIM: An Execution-Driven Simulator for ILP-Based Shared-Memory Multiprocessors and Uniprocessors,” Workshop on Computer Architecture Education (WCAE 97), February 1997. [3] A. Misev and M. Gusev, “Visual simulator for ILP dynamic OOO processor,” in Proceedings of the Workshop on Computer Architecture Education, ISCA 2004, pp.87-92, 2004. [4] K. Skadron, “A microprocessor survey course: Exploring advanced computer architecture in practice,” In Proceedings of the Workshop on Computer Architecture Education, June 2000. [5] J. Djordjevic, B. Nikolic and A. Milenkovic, “Flexible Web-based Educational System for Teaching Computer Architecture and Organization,” IEEE Transactions on Education, vol. 48, no. 2, pp 264-273, 2005. [6] Moodle: http://moodle.org/ (last accessed: 15/02/2006) [7] A. Martínez, Y. Dimitriadis, B. Rubia, E. Gómez and P. de la Fuente, “Combining qualitative evaluation and social network analysis for the study of classroom social interactions,” Computers and Education, vol. 41, no. 4, pp. 353-368, 2003. [8] A. Inaba, T. Supnithi, M. Ikeda, R. Mizoguchi and J. Toyoda, “How can we form effective collaborative learning groups?,” in Proceedings of the 5th International Conference on Intelligent Tutoring Systems, pp. 282-291, 2000. [9] B. Gifford and N. D. Enyedy, “Activity centered design: towards a theoretical framework for CSCL,” in Proceedings of the Third International Conference On Computer Support For Collaborative Learning, pp. 189 – 196, 1999. [10] A. Harrer, N. Malzahn, K. Hoeksema and U. Hoppe, “Learning Design Engines as Remote Control to Learning Support Environments,” Journal of Interactive Media in Education (Advances in Learning Design. Special Issue, eds. Colin Tattersall, Rob Koper), 2005. [11] N. Pinkwart, “Synchronization Contexts as a Means to Support Collaborative Modeling,” in Proceedings of the international Workshop on Groupware (CRIWG 2005), Springer, Berlin, pp. 145-152, 2005. [12] Y. Miao, and U. Hoppe, “Adapting Process-Oriented Learning Designs to Group Characteristics,” In C. K. Looi, G. McCalla, B. Bredeweg, & J. Breuker Eds., Supporting Learning through Intelligent and Socially Informed technology, Proceedings of the 12th Conference on Artificial Intelligence in Education, pp. 475-482, IOS Press, 2005. [13] Y. Miao, K. Hoeksema, H. U. Hoppe and A. Harrer, “CSCL Scripts: Modelling Features and Potential Use,” in Proceedings of the International Conference on Computer Supported Collaborative Learning (CSCL2005), Taiwan, June 2005. [14] Y. Miao, “Supporting Situated Learning for Virtual Communities of Practice: Representation and Management of Situated Knowledge,” in Kinshuk, Chee-Kit Looi, Erkki Sutinen et.al. Eds., Proceedings of the 4th IEEE International
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
Conference on Advanced Learning Technologies, ICALT 2004, pp. 490-494, Joensuu, Finland, 2004. [15] M. Kuhn, M. Jansen, A. Harrer and H. U. Hoppe, “A Lightweight Approach for Flexible Group Management in the Classroom,” in Proceedings of the International Conference on Computer Supported Collaborative Learning (CSCL2005), Taiwan, June 2005. [16] J. Bruner, Acts of Meaning, Cambridge, MA: Harvard University Press, 1990. [17] J. Bruner, The Culture of Education, Cambridge, MA: Harvard University Press, 1996. [18] T. Koschman, Theory and Practice of an Emerging Paradigm, Mahwah, N.J. Lawrence Erlbaum, 1996. [19] D.H. Jonassen, D. Cernusca and I.G. Ionas, “Constructivism and instructional design: The emergence of the learning sciences and design research,” in R. Reiser & J. Dempsey (Eds.), Trends and issues in instructional design and technology, Columbus, OH: Merrill/Prentice-Hall, 2006. [20] C. Crook, Computers and the Collaborative Experience of Learning, New York, NY, Routledge, 1994. [21] R. A. Knuth and D. J. Cunningham, “Tools for constructivism,” in Constructivism and the Technology of Instruction: A Conversation, T. M. Duffy, and D. H. Jonassen (Eds.), pp. 163–187, Hillsdale, NJ: Lawrence Erlbaum Associates.1991. [22] R. J. Spiro, P. J. Feltovich., M. J. Jacobson and R. L. Coulson, “Knowledge representation, content specification, and the development of skill in situationspecific knowledge assembly: Some constructivist issues as they relate to cognitive flexibility theory and hypertext,” Educational Technology, 31 (9), 2225, 1991. [23] S. Papert, “Constructionism: a new opportunity for elementary science education,” A proposal to the National Science Foundation. M.I.T., Media Lab., Epistemology and Learning Group, Cambridge, MA, USA, 1986. [24] E. Martí, Aprender con Ordenadores en la Escuela, Barcelona: ICEUniversitat de Barcelona/Horsori, 1992 [25] L. Vygotsky, Mind in Society: The Development of Higher Psychological Processes, Cambridge, MA: Harvard University Press, 1978. [26] L. Lipponen, “Exploring foundations for computer-supported collaborative learning,” in Proceedings of the Computer-supported Collaborative Learning 2002 Conference, pp. 72-81, Hillsdale, NJ: Erlbaum, 2002. [27] C. Osuna, “DELFOS: A Telematic and Educational Framework based on Layer oriented to Learning Situations,” Ph. D. thesis, Universidad de Valladolid, Valladolid, Spain, 2000. [28] M. Xenos, N. M. Avouris, V. Komis, D. Stavrinoudis and M. Margaritis, “Synchronous Collaboration in Distance Education: A Case Study on a Computer Science Course,” in Proceedings of the IEEE International Conference on Advanced Learning Technologies, ICALT 2004, Joensuu, Finland, 2004.
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
[29] M. Grigoriadou, M. Toula, E. Kanidis, “Design and Evaluation of a Cache Memory Simulation Program,” ICALT 2003: 170-174. 2003. [30] M. Gogoulou, E. Gouli, M. Grigoriadou and M. Samarakou, “Exploratory + Collaborative Learning in Programming: A Framework for the Design of Learning Activities,” ICALT 2003: 350-351. 2003. [31] M. Gogoulou, E. Gouli, M. Grigoriadou and M. Samarakou, “Supporting Collaboration and Adaptation in a CSCL Environment,” ICALT 2003: 470. 2003. [32] A. W. Chickering and Z. F. Gamson, “Applying the Seven Principles for Good Practice in Undergraduate Education,” New Directions for Teaching and Learning Vol. 47 (1991), San Francisco: Jossey-Bass Inc., Publishers. [33] Hatfield, Susan Rickey, ed. The Seven Principles in Action. Bolton, Mass.: Anker Publishing Company, Inc.,1995. [34] A. Deursen, E. Visser, “The Reengineering Wiki,” in Proceedings of the 6th European Conference on Software Maintenance and Reengineering: 217. 2002. IEEE Computer Society, Washington, DC, USA. [35] R. M. Felder, G. M. Felder and E. J. Dietz, “A longitudinal study of Engineering student performance and retention vs comparisons with traditional taugh students” J. Engineering Education, vol. 87, no. 4, pp. 469-480, 1995. [36] S. Vosniadou and V. Kolias, “Using Collaborative, Computer-Supported, Model Building to Promote Conceptual Change in Science,” in Powerful learning environments: Unravelling basic components and dimensions, E. De Corete, L. Verschaffel, N. Entwistel and J. Van Merrienboer (Eds), Advances in Learning and Instruction, Elsevier Press, 2003. [37] G. Denhiere and S. Baudet, “Lecture, comprehension de texte et science cognitive,” Presses Universitaires de France, Paris, pp. 214-232, 1992 [38] J. Edler and M. Hill, Dinero IV: Trace-Driven Uniprocessor Cache Simulator, University of Winconsin. Available: http://www.cs.wisc.edu/~markhill/DineroIV (last accessed: 15/02/2006). [39] M. Scott, WinMIPS64, http://www.computing.dcu.ie/~mike/winmips64.html (last accessed: 15/02/2006). [40] P. López and R. Calpé, DLXVSim, Universidad Politécnica de Valencia. [41] M. Wolff and L. Wills, “SATSim: A Superscalar Architecture trace simulator using interactive animation,” in Proceedings WCAE 2000, Workshop on Computer Architecture Education, Vancouver, BC, June 10, 2000. Published in IEEE Computer Architecture Technical Committee Newsletter, September 2000, pp. 27-33. Available: http://www.ece.gatech.edu/research/pica/SATSim/satsim.html (last accessed: 15/02/2006). [42] T. Austin, E. Larson, and D. Ernst. “SimpleScalar: An infrastructure for computer system modelling,” IEEE Computer, 35:59–67, Feb. 2002. [43] V. Cuppu, “Cycle accurate simulator for TMS320C62x, 8 way VLIW DSP processor,” ENEE 646-Digital Computer Design, Class Project Report, Univ. of Maryland, College Park, 1999. Available: http://citeseer.ist.psu.edu/416529.html (last accessed: 15/02/2006). [44] T. Austin, “SimpleScalar Hacker’s Guide (for tool set release 2.0),” Technical Report. Available: www.simplescalar.com (last accessed: 15/02/2006).
Lorenzo Moreno, Carina S. González, Ivan Castilla, Evelio J. González, and José F. Sigut (2007). Use of Constructivism and Collaborative Teaching in an ILP Processors Course. IEEE Trans. Education 50(2):101-111.
[45] R. M. Tomasulo, “An efficient algorithm for exploiting multiple arithmetic units,” IBM Journal Research and Development, vol. 11, no. 1, pp. 25–33, January 1967. [46] SIMDE. Available: http://www.cyc.ull.es/simde (last accessed: 15/02/2006) [47] C. González, E. González, V. Muñoz, J. Sigut, “Una Experiencia de Aprendizaje Colaborativo en la Universidad Utilizando Wikis en Moodle,” SIECI 2005. Orlando, Florida, USA, July 2005. [48] D. Sima, T. Fountain and P. Kacsuk, Advanced Computer Architectures: A Design Space Approach. Harlow, England: Addison-Wesley, 1997. [49] B. Dodge, “WebQuests: a technique for Internet-based learning,” Distance Educator, vol. 1, no. 2, pp.10-13, 1995. [50] L. Harvey, “Student feedback: a report to the Higher Education Funding Council for England”. Available: http://www.uce.ac.uk/crq/publications/studentfeedback.pdf, October 2001 (last accessed: 15/02/2006) [51] I. Castilla, L. Moreno, J. Sigut, C. González and E. J. González, “SIMDE: Un simulador para el apoyo docente en la enseñanza de las arquitecturas ILP con planificación dinámica y estática,” in Proceedings of X Jornadas de ENseñanza Universitaria de la Informática (JENUI 2004), pp. 505-508, July 2004.