27 | { props.op }
28 |
29 | )
30 | }
31 |
32 | export default VLIWOperationComponent;
33 |
--------------------------------------------------------------------------------
/docs/en/instruction-level-paralelism.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: en
4 | id: instruction-level-paralelism
5 | title: ILP
6 | prev: en/introduccion.html
7 | next: en/menu-archivo.html
8 | ---
9 |
10 | Instruction Level Parallelism is the potential ability of a set of instruction to be executed in parallel.
11 |
12 | There are lots of techniques that try to exploit ILP such as segmentation or Multiple Issue. This simulator illustrates two basic flavours of processors with multiple instruction issue per clock.
13 |
14 |
15 | ## Dynamic Instruction Scheduling
16 |
17 | Instructions are reordered by hardware in order to exploit parallelism. It results in an out-of-order execution. Most of Superscalar processors use this kind of execution .
18 |
19 |
20 | ## Static Instruction Scheduling
21 |
22 | Instructions are reordered by the compiler in order to exploit parallelism. Thus, hardware is significantly reduced. It results in an in-order execution and this is the basic technique that VLIW processors employe.
23 |
--------------------------------------------------------------------------------
/src/test/functional/code/multiwayvliw1.ts:
--------------------------------------------------------------------------------
1 | export const codeInput = `// SWMDE v0.1
2 | // Ejemplo simple para poder hacer uso de los predicados en la máquina VLWW
3 | // En memoria, a partir de la pos. 10 deben encontrarse dos números flotantes
4 | // En R32 se supone que viene un parámetro que indica si coger el primero (0)
5 | // el segundo(1) o la suma (resto) y guarda el resultado
6 | // en la pos. de memoria siguiente (12)
7 | // F0 en teoría vale 0
8 | // NUMERO DE INSTRUCCIONES:
9 | 13
10 | // CODIGO:
11 | ADDI R10, R0, #10
12 | ADDI R1, R0, #0
13 | ADDI R2, R0, #1
14 | LF F1, 0(R10)
15 | LF F2, 1(R10)
16 | BNE R32, R1, A
17 | ADDF F3, F1, F0
18 | BEQ R0, R0, FIN
19 | A:
20 | BNE R32, R2, B
21 | ADDF F3, F2, F0
22 | BEQ R0, R0, FIN
23 | B:
24 | ADDF F3, F2, F1
25 | FIN:
26 | SF F3, 2(R10)`;
27 |
28 | export const vliwCodeInput = `11
29 | 2 0 0 0 0 1 0 1 0
30 | 3 2 0 0 0 3 4 0 0 4 4 1 0
31 | 0
32 | 0
33 | 1 5 5 0 0 6 1 2
34 | 2 6 2 0 2 8 5 0 1 7 3 4
35 | 2 9 2 0 4 11 2 1 3
36 | 0
37 | 0
38 | 0
39 | 1 12 4 0 0`;
--------------------------------------------------------------------------------
/src/i18n.ts:
--------------------------------------------------------------------------------
1 | import i18n from "i18next";
2 | import { initReactI18next } from "react-i18next";
3 | import HttpApi from 'i18next-http-backend';
4 | import LanguageDetector from 'i18next-browser-languagedetector';
5 |
6 |
7 | i18n
8 | .use(HttpApi)
9 | .use(LanguageDetector)
10 | .use(initReactI18next)
11 | .init({
12 | fallbackLng: 'en',
13 | backend: {
14 | loadPath: `${import.meta.env.BASE_URL}locales/{{lng}}/{{ns}}.json`
15 | },
16 | react: {
17 | useSuspense: true
18 | },
19 | // have a common namespace used around the full app
20 | ns: ['common'],
21 | defaultNS: 'common',
22 | debug: false,
23 | cache: {
24 | enabled: true
25 | },
26 | interpolation: {
27 | escapeValue: false,
28 | formatSeparator: ',',
29 | format: function (value, format) {
30 | if (format === 'uppercase') {
31 | return value.toUpperCase();
32 | }
33 | return value;
34 | }
35 | }
36 | });
37 |
38 | export default i18n;
39 |
--------------------------------------------------------------------------------
/docs/es/estaciones-de-reserva.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: es
4 | id: estaciones-de-reserva
5 | title: Estaciones de reserva
6 | prev: reorder-buffer.html
7 | next: calculo-de-direcciones.html
8 | ---
9 |
10 |
11 | Estructura en la que permanecen las instrucciones mientras esperan por sus operandos o se ejecutan en la U. F. correspondiente.
12 | Tienen tantas entradas como una más que el número de etapas de la U.F. correspondiente multiplicada por el número de U.F. de ese tipo que haya.
13 |
14 |
15 | ### Campos
16 |
17 | * Inst.: Identificador de la instrucción
18 | * Qj: Disponibilidad del primer operando. -1 indica que el valor se encuentra en Vj; otro valor indica la posición del ROB donde se está procesando el operando.
19 | * Vj: Valor del primer operando si (Qj = -1).
20 | * Qk: Disponibilidad del segundo operando. -1 indica que el valor se encuentra en Vk; otro valor indica la posición del ROB donde se está procesando el operando.
21 | * Vk: Valor del segundo operando si (Qk = -1).
22 | * A: Dirección de memoria
23 | * ROB: Posición del ROB donde está esta instrucción
24 |
--------------------------------------------------------------------------------
/src/core/VLIW/LargeInstructions.ts:
--------------------------------------------------------------------------------
1 | import { VLIWOperation } from './VLIWOperation';
2 |
3 | export class LargeInstruction {
4 |
5 | private _operations: VLIWOperation[];
6 | private _breakPoint: boolean;
7 |
8 | constructor() {
9 | this._operations = [];
10 | this._breakPoint = false;
11 | }
12 |
13 | get operations(): VLIWOperation[] {
14 | return this._operations;
15 | }
16 |
17 | public getOperation(index: number): VLIWOperation {
18 | if (index > this._operations.length) {
19 | throw new Error('Index out of bounds at operations');
20 | }
21 | return this._operations[index];
22 | }
23 |
24 | public getVLIWOperationsNumber(): number {
25 | return this._operations.length;
26 | }
27 |
28 | public setBreakPoint(value: boolean) {
29 | this._breakPoint = value;
30 | }
31 |
32 | public getBreakPoint(): boolean {
33 | return this._breakPoint;
34 | }
35 |
36 | addOperation(operation: VLIWOperation) {
37 | this._operations.push(operation);
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/src/test/functional/Superscalar/r0inmutable.spec.ts:
--------------------------------------------------------------------------------
1 | import { expect, beforeEach, test } from 'vitest'
2 | import { Code } from '../../../core/Common/Code';
3 | import { Superscalar } from '../../../core/Superscalar/Superscalar';
4 | import { SuperscalarStatus } from '../../../core/Superscalar/SuperscalarEnums';
5 | import { code } from '../code/r0inmutable';
6 |
7 |
8 | const context: { code: Code, machine: Superscalar } = { code: null, machine: null };
9 |
10 | beforeEach(() => {
11 | context.code = new Code();
12 | context.machine = new Superscalar();
13 | context.machine.init(true);
14 | });
15 |
16 | test('Register R0 is inmutable', t => {
17 | // Execute code
18 | context.code.load(code);
19 | context.machine.code = context.code;
20 | while (context.machine.tic() !== SuperscalarStatus.SUPER_ENDEXE) { }
21 |
22 | // Check R1 value
23 | expect(context.machine.getGpr(1)).toBe(0);
24 |
25 | // Check where the program counter is
26 | expect(context.machine.pc).toBe(2);
27 |
28 | // Check the number of cycles are correct
29 | expect(context.machine.status.cycle).toBe(6);
30 | })
--------------------------------------------------------------------------------
/docs/es/barra-de-herramientas-estandar.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: es
4 | id: barra-de-herramientas-estandar
5 | title: Barra de herramientas estándar
6 | prev: menu-ayuda.html
7 | next: barra-de-herramientas-de-ejecucion.html
8 | ---
9 |
10 | Contiene las opciones más comunes del programa.
11 |
12 | 
13 |
14 |  Permite abrir un fichero con código secuencial.
15 |
16 |  Habilita la opción de colorear los bloques básicos en el código.
17 |
18 |  Muestra/oculta el código secuencial cargado de fichero.
19 |
20 |  Abre la ventana de Configuración de la Máquina Superescalar, con la que se pueden modificar sus parámetros más importantes.
21 |
22 |  Abre la ventana de Configuración de la Máquina VLIW, con la que se pueden modificar sus parámetros más importantes.
23 |
24 |  Permite establecer el porcentaje de fallos de caché de datos al realizar una instrucción de carga (LOAD). 0 significa que no habrá ningún fallo y 100 significa que todos los accesos producen fallo.
--------------------------------------------------------------------------------
/src/test/functional/code/bucle2.ts:
--------------------------------------------------------------------------------
1 | export const codeInput = `// SWMDE v1.0
2 | // Autor: Iván Castilla Rodríguez
3 | // Utilidad: Programa de testeo de SWMDE
4 | // Comentarios: El programa presupone q en la posición 50 (R2) de memoria tienes
5 | // un vector de de 16 elementos y quieres sumar a cada elemento una cantidad
6 | // fija (en la posición de memoria 40). El resultado se coloca a partir de la
7 | // posición 70 (R3) de memoria.
8 | // Este fichero es el mismo bucle de "bucle.pla" pero desenrollado para que en
9 | // cada iteración se hagan dos pasadas del bucle
10 | //
11 | 14
12 | ADDI R2 R0 #50
13 | ADDI R3 R0 #70
14 | ADDI R4 R0 #40
15 | LF F0 (R4)
16 | ADDI R5 R2 #16
17 | LOOP:
18 | LF F1 (R2)
19 | LF F2 1(R2)
20 | ADDF F1 F1 F0
21 | ADDF F2 F2 F0
22 | SF F1 (R3)
23 | SF F2 1(R3)
24 | ADDI R2 R2 #2
25 | ADDI R3 R3 #2
26 | BNE R2 R5 LOOP`;
27 |
28 | export const vliwCodeInput = `15
29 | 2 0 0 0 0 2 0 1 0
30 | 3 1 0 0 0 4 0 1 0 3 4 0 0
31 | 2 5 4 0 0 6 4 1 0
32 | 0
33 | 0
34 | 0
35 | 2 7 2 0 0 8 2 1 0
36 | 0
37 | 0
38 | 0
39 | 2 9 4 0 0 10 4 1 0
40 | 0
41 | 1 11 0 0 0
42 | 1 13 5 0 0 2 1 2
43 | 1 12 0 1 0`;
--------------------------------------------------------------------------------
/src/test/functional/code/bucle.ts:
--------------------------------------------------------------------------------
1 | export const codeInput = `// SWMDE v0.1
2 | // Autor: Iván Castilla Rodríguez
3 | // Utilidad: Programa de testeo de SWMDE
4 | // Comentarios: El programa presupone q en la posición 50 (R2) de memoria tienes un vector de
5 | // 16 elementos y quieres sumar a cada elemento una cantidad fija (en la posición de memoria
6 | // 40). El resultado se coloca a partir de la posición 70 (R3) de memoria.
7 | 11
8 | ADDI R2 R0 #50
9 | ADDI R3 R0 #70
10 | ADDI R4 R0 #40
11 | LF F0 (R4)
12 | ADDI R5 R2 #16
13 | LOOP:
14 | LF F1 (R2)
15 | ADDF F1 F1 F0
16 | SF F1 (R3)
17 | ADDI R2 R2 #1
18 | ADDI R3 R3 #1
19 | BNE R2 R5 LOOP`;
20 |
21 | export const vliwCodeInput = `15
22 | 2 0 0 0 0 2 0 1 0
23 | 3 1 0 0 0 4 0 1 0 3 4 0 0
24 | 1 5 4 0 0
25 | 0
26 | 0
27 | 0
28 | 1 6 2 0 0
29 | 1 8 0 0 0
30 | 0
31 | 0
32 | 1 7 4 1 0
33 | 0
34 | 0
35 | 1 10 5 0 0 2 1 2
36 | 1 9 0 1 0`;
37 |
38 | export const vecContent = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
39 | export const sumContent = 0.5;
40 | export const resultContent = [1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5 ,8.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5, 16.5];
--------------------------------------------------------------------------------
/docs/es/maquina-vliw.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: es
4 | id: maquina-vliw
5 | title: Máquina vliw
6 | prev: calculo-de-direcciones.html
7 | next: nat-gpr-fpr.html
8 | ---
9 |
10 | 
11 |
12 | Características
13 |
14 | 1. Hardware extremadamente simple.
15 |
16 | 2. Emisión de una instrucción larga por ciclo
17 |
18 | 3. La instrucción tiene tantas operaciones y de igual tipo que el número de UF que haya.
19 |
20 | 4. Emplea operaciones predicadas.
21 |
22 |
23 | ### Componentes
24 |
25 | * **Nat(GPR)**: Bits de NaT (Not a Thing). Se ponen a TRUE cuando el registro de propósito general asociado es destino de una operación de LOAD que tuvo un fallo de caché.
26 |
27 | * **NaT (FPR)**: Bits de NaT (Not a Thing). Se ponen a TRUE cuando el registro de punto flotante asociado es destino de una operación de LOAD que tuvo un fallo de caché.
28 |
29 | * **Reg. Pred.**: Registros de Predicado.
30 |
31 | * **U.F.**: Unidades Funcionales
32 |
33 | En la máquina VLIW se denomina "operación" a las instrucciones del código secuencial (ADDI, LF...). En general, se entenderá por "instrucción" la instrucción larga compuesta de operaciones.
--------------------------------------------------------------------------------
/src/interface/components/Superscalar/PrefetchDecoderComponent.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import { useTranslation } from 'react-i18next';
3 |
4 | export function PrefetchDecoderComponent(props) {
5 | const [t, i18n] = useTranslation();
6 |
7 | return (
8 |
9 |
);
22 | }
23 |
24 |
25 | export default PrefetchDecoderComponent;
26 |
--------------------------------------------------------------------------------
/docs/_book/gitbook/gitbook-plugin-search/search.css:
--------------------------------------------------------------------------------
1 | /*
2 | This CSS only styled the search results section, not the search input
3 | It defines the basic interraction to hide content when displaying results, etc
4 | */
5 | #book-search-results .search-results {
6 | display: none;
7 | }
8 | #book-search-results .search-results ul.search-results-list {
9 | list-style-type: none;
10 | padding-left: 0;
11 | }
12 | #book-search-results .search-results ul.search-results-list li {
13 | margin-bottom: 1.5rem;
14 | padding-bottom: 0.5rem;
15 | /* Highlight results */
16 | }
17 | #book-search-results .search-results ul.search-results-list li p em {
18 | background-color: rgba(255, 220, 0, 0.4);
19 | font-style: normal;
20 | }
21 | #book-search-results .search-results .no-results {
22 | display: none;
23 | }
24 | #book-search-results.open .search-results {
25 | display: block;
26 | }
27 | #book-search-results.open .search-noresults {
28 | display: none;
29 | }
30 | #book-search-results.no-results .search-results .has-results {
31 | display: none;
32 | }
33 | #book-search-results.no-results .search-results .no-results {
34 | display: block;
35 | }
36 |
--------------------------------------------------------------------------------
/docs/en/maquina-superescalar.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: en
4 | id: maquina-superescalar
5 | title: Superescalar Machine
6 | prev: en/unidades-funcionales.html
7 | next: en/unidad-de-prebusqueda.html
8 | ---
9 |
10 | 
11 |
12 | ### Characteristics
13 |
14 | 1. Control of the processor based on Tomasulo's algorithm.
15 |
16 | 2. The Issue Rate is the most important parameter for this processor. The Issue Rate is the maximum number of instructions issued per cycle (and consequently the maximum number of instructions that may commit per cycle).
17 |
18 | 3. It uses dynamic branch prediction.
19 |
20 |
21 | ### Components
22 |
23 | * **Prefetch**: Prefetch unit.
24 |
25 | * **Decoder**: Decoder Unit
26 |
27 | * **ROB<->GPR**: ROB entry where a General Purpose Register is being processed.
28 |
29 | * **ROB<->FPR**: ROB entry where a Floating Point Register is being processed.
30 |
31 | * **Branch Prediction**: 2-bit Branch Prediction Table.
32 |
33 | * **ROB**: Reorder Buffer.
34 |
35 | * **RE**: Reservation Stations.
36 |
37 | * **FU**: Functional Units.
38 |
39 | * **Address computing ALU**: This unit computes memory addresses.
--------------------------------------------------------------------------------
/src/interface/App.tsx:
--------------------------------------------------------------------------------
1 | import * as React from "react";
2 | import {BrowserRouter, Routes, Route } from 'react-router-dom';
3 | import LandingPageComponent from "./components/LandingPage/LandingPageComponent";
4 | import ProjectPage from "./components/LandingPage/ProjectPageComponent";
5 |
6 | import SuperscalarComponent from "./components/Superscalar/SuperscalarComponent";
7 | import VLIWComponent from "./components/VLIW/VLIWComponent";
8 |
9 |
10 | const App = () => {
11 | return (
12 |
10 | {t(props.title)}
11 |
12 |
21 |
13 | {
14 | props.data && props.data.map((element, i) =>
15 |
20 |
16 |
)
18 | }
19 | {element != null ? element.id : ` `}
17 |
14 | Loading...
}>
15 |
23 |
29 | )
30 | }
31 |
32 | export default InstructionComponent;
33 |
--------------------------------------------------------------------------------
/src/test/functional/Superscalar/newop.spec.ts:
--------------------------------------------------------------------------------
1 | import { expect, beforeEach, test } from 'vitest'
2 | import { Code } from '../../../core/Common/Code';
3 | import { Superscalar } from '../../../core/Superscalar/Superscalar';
4 | import { SuperscalarStatus } from '../../../core/Superscalar/SuperscalarEnums';
5 | import { codeInput, resultContent } from "../code/nuevaOp";
6 |
7 |
8 | const context: { code: Code, machine: Superscalar } = { code: null, machine: null };
9 |
10 | beforeEach(() => {
11 | context.code = new Code();
12 | context.machine = new Superscalar();
13 | context.machine.init(true);
14 | });
15 |
16 | test('nuevaOp.pla is executed properly', t => {
17 | // Execute code
18 | context.code.load(codeInput);
19 | context.machine.code = context.code;
20 | while (context.machine.tic() !== SuperscalarStatus.SUPER_ENDEXE) { }
21 |
22 | // Check registers
23 | const resultBase = 2;
24 | const result = context.machine.gpr.content.slice(
25 | resultBase, resultBase + resultContent.length
26 | );
27 | expect(result).toStrictEqual(resultContent);
28 |
29 | // Check where the program counter is
30 | expect(context.machine.pc).toBe(7);
31 |
32 | // Check the number of cycles are correct
33 | expect(context.machine.status.cycle).toBe(14);
34 |
35 | })
--------------------------------------------------------------------------------
/src/core/Common/Memory.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * Returns an Error when target method is called with
3 | * a non-positive `address: number` argument.
4 | */
5 | export const forcePositiveAddresses = (address: number): Error | undefined => {
6 | if (address < 0) {
7 | return Error("Negative numbers are invalid as addresses");
8 | }
9 | };
10 |
11 | export class Memory implements Iterable{props.instruction.label} {props.loc}
24 | {OpcodesNames[props.instruction.opcode]}
25 | {props.instruction.operandsString[0]}
26 | {props.instruction.operandsString[1]}
27 | {props.instruction.operandsString[2]}
28 |
14 |
39 | );
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/docs/en/unidades-funcionales.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: en
4 | id: unidades-funcionales
5 | title: Functional Units
6 | prev: en/registros-de-punto-flotante.html
7 | next: en/maquina-superescalar.html
8 | ---
9 |
10 | The Functional Units (FU) are the basic unit for the processor execution.
11 |
12 | They are pipelined, with 1 cycle per pipeline stage. Thus, a new instruction (operation of a VLIW processor) enters in the pipeline each cycle unless it has a true dependence with the previous instruction. If this is the case, the entering instruction must be stalled until the previous instruction has finished. The time the instruction is stalled is called Latency and it fits with the number of pipeline stages.
13 |
14 |
15 | ### Types
16 |
17 | * Integer Add: It performs the ADDI and ADD operations, and the address computing for the superscalar processor (the VLIW processor includes this work in the memory FU).
18 |
19 | * Integer Multiplication: It performs the MULT operation.
20 |
21 | * FP Add: It performs the ADDF operation.
22 |
23 | * FP Multiplication: It performs the MULTF operation.
24 |
25 | * Memory: It performs all the memory operations (LW, LF, SW, SF). The VLIW processor adds an ALU for address computing into this unit.
26 |
27 | * Branch: It performs all branch operations. It evaluates conditions and change the PC (if it's necessary). Branch Prediction Table in superscalar processor is handled by this unit too).
28 |
--------------------------------------------------------------------------------
/src/test/functional/Superscalar/speculativenosideeffects.spec.ts:
--------------------------------------------------------------------------------
1 | import { expect, beforeEach, test } from 'vitest'
2 | import { Code } from '../../../core/Common/Code';
3 | import { Superscalar } from '../../../core/Superscalar/Superscalar';
4 | import { SuperscalarStatus } from '../../../core/Superscalar/SuperscalarEnums';
5 | import { codeInput } from '../code/speculativenosideeffects';
6 |
7 |
8 | const context: { code: Code, machine: Superscalar } = { code: null, machine: null };
9 |
10 | beforeEach(() => {
11 | context.code = new Code();
12 | context.machine = new Superscalar();
13 | context.machine.init(true);
14 | });
15 |
16 | test('Speculative execution has no side effects', t => {
17 | // Execute code
18 | context.code.load(codeInput);
19 | context.machine.code = context.code;
20 | while (context.machine.tic() !== SuperscalarStatus.SUPER_ENDEXE) { }
21 |
22 | // Check R5 value
23 | expect(context.machine.getGpr(5)).toBe(0);
24 |
25 | // Check memory pos 5 value
26 | expect(Array.from(context.machine.memory)[5]).toBe(0);
27 |
28 | // Check F1 value
29 | expect(context.machine.getFpr(1)).toBe(0);
30 |
31 | // Check jump prediction table
32 | expect(context.machine.jumpPrediction.getPrediction(7)).toBe(false);
33 |
34 | // Check where the program counter is
35 | expect(context.machine.pc).toBe(9);
36 |
37 | // Check the number of cycles are correct
38 | expect(context.machine.status.cycle).toBe(30);
39 | })
--------------------------------------------------------------------------------
/docs/es/ventana-de-instrucciones.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: es
4 | id: ventana-de-instrucciones
5 | title: Ventana de instrucciones
6 | prev: barra-de-herramientas-de-ejecucion.html
7 | next: configurar-parametros-superescalar.html
8 | ---
9 |
10 | La Ventana de Instrucciones permite visualizar el código secuencial cargado desde un fichero.
11 |
12 | 
13 |
14 | Las instrucciones se muestran en orden secuencial.
15 |
16 | En la primera columna aparece el número de orden de la instrucción, que servirá como Identificador. También aparecen en esta columna las etiquetas entre corchetes ([etiqueta:]) a continuación del número de instrucción.
17 |
18 | La segunda columna es el código de la operación (opcode).
19 |
20 | Las siguientes columnas son los operandos.
21 |
22 |
23 | ### Breakpoints
24 |
25 | Haciendo doble clic sobre cualquier campo de la instrucción se establece un Breakpoint válido para la ejecución superescalar (los Breakpoints de la máquina VLIW se indican sobre las instrucciones largas). El breakpoint se indica con el color rojo en la columna del Identificador. Para quitar el Breakpoint basta con volver a hacer doble clic.
26 |
27 |
28 | ### Ocultar el código
29 |
30 | Si se hace doble clic en el título con el nombre del fichero, se ocultará está ventana. Para volver a verla hay que ir al menú Ver => Código Secuencial..
31 |
32 |
33 | ### Bloques básicos
34 |
35 | Para colorear los Bloques Básicos del código basta con ir al menú Ver => Bloques Básicos.
--------------------------------------------------------------------------------
/src/test/functional/VLIW/shift.spec.ts:
--------------------------------------------------------------------------------
1 | import { expect, beforeEach, test } from "vitest";
2 | import { VLIW } from "../../../core/VLIW/VLIW";
3 | import { VLIWCode } from "../../../core/VLIW/VLIWCode";
4 | import { Code } from "../../../core/Common/Code";
5 | import { VLIWError } from "../../../core/VLIW/VLIWError";
6 | import { codeInput, vliwCodeInput, resultContent } from "../code/despl";
7 |
8 | const context: { code: VLIWCode; superscalarCode: Code; machine: VLIW } = {
9 | code: null,
10 | superscalarCode: null,
11 | machine: null,
12 | };
13 |
14 | beforeEach(() => {
15 | context.code = new VLIWCode();
16 | context.superscalarCode = new Code();
17 | context.machine = new VLIW();
18 | context.machine.init(true);
19 | });
20 |
21 | test("Despl.pla is executed properly", () => {
22 | // Load code
23 | context.superscalarCode.load(codeInput);
24 | context.code.load(vliwCodeInput, context.superscalarCode);
25 | context.machine.code = context.code;
26 |
27 | // Execute code
28 | while (context.machine.tic() !== VLIWError.ENDEXE) {}
29 |
30 | // Check where the program counter is
31 | expect(context.machine.pc).toBe(8);
32 |
33 | // Check the result
34 | const resultBaseAddress = 1;
35 | const result = context.machine.gpr.content.slice(
36 | resultBaseAddress,
37 | resultBaseAddress + resultContent.length,
38 | );
39 | expect(result).toStrictEqual(resultContent);
40 |
41 | // Check the cycles
42 | expect(context.machine.status.cycle).toBe(10);
43 | });
44 |
--------------------------------------------------------------------------------
/docs/es/unidades-funcionales.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: es
4 | id: unidades-funcionales
5 | title: Unidades funcionales
6 | prev: registros-de-punto-flotante.html
7 | next: maquina-superescalar.html
8 | ---
9 |
10 | Las Unidades Funcionales (UF) son las únidades básicas de ejecución de la máquina.
11 |
12 | Son segmentadas, y cada etapa del pipeline dura 1 ciclo exactamente. De esta manera, cada ciclo puede entrar una nueva instrucción a menos que tenga una dependencia verdadera con la instrucción anterior. En ese caso, deberá esperar hasta que la instrucción anterior haya acabado completamente su ejecución. A este tiempo lo denominamos latencia de la UF, y coincide con el número de etapas del pipeline.
13 |
14 | ### Tipos
15 |
16 | * Suma entera: Para efectuar las operaciones ADD y ADDI, y el cálculo de direcciones en la VLIW (en la máquina superescalar esta función se considera integrada en la UF de memoria).
17 |
18 | * Multiplicación entera: Efectúa la operación MULT.
19 |
20 | * Suma flotante: Efectúa la operación ADDF.
21 |
22 | * Multiplicación flotante: Efectúa la operación MULTF.
23 |
24 | * Memoria: Se encarga de todas las operaciones referentes a memoria (LW, SW, LF, SF). En la máquina Superescalar se considera que tiene integrada una ALU para el cálculo de direcciones, mientras que en la VLIW sólo representa el tiempo de acceso a la memoria
25 |
26 | * Salto: Se encarga de las operaciones de salto, evaluando las condiciones y cambiando el PC (y la tabla de predicción en la máquina Superescalar).
--------------------------------------------------------------------------------
/docs/_book/gitbook/gitbook-plugin-search/search-engine.js:
--------------------------------------------------------------------------------
1 | require([
2 | 'gitbook',
3 | 'jquery'
4 | ], function(gitbook, $) {
5 | // Global search objects
6 | var engine = null;
7 | var initialized = false;
8 |
9 | // Set a new search engine
10 | function setEngine(Engine, config) {
11 | initialized = false;
12 | engine = new Engine(config);
13 |
14 | init(config);
15 | }
16 |
17 | // Initialize search engine with config
18 | function init(config) {
19 | if (!engine) throw new Error('No engine set for research. Set an engine using gitbook.research.setEngine(Engine).');
20 |
21 | return engine.init(config)
22 | .then(function() {
23 | initialized = true;
24 | gitbook.events.trigger('search.ready');
25 | });
26 | }
27 |
28 | // Launch search for query q
29 | function query(q, offset, length) {
30 | if (!initialized) throw new Error('Search has not been initialized');
31 | return engine.search(q, offset, length);
32 | }
33 |
34 | // Get stats about search
35 | function getEngine() {
36 | return engine? engine.name : null;
37 | }
38 |
39 | function isInitialized() {
40 | return initialized;
41 | }
42 |
43 | // Initialize gitbook.search
44 | gitbook.search = {
45 | setEngine: setEngine,
46 | getEngine: getEngine,
47 | query: query,
48 | isInitialized: isInitialized
49 | };
50 | });
--------------------------------------------------------------------------------
/src/interface/actions/stats-actions.ts:
--------------------------------------------------------------------------------
1 | export const NEXT_TOTAL_COMMITED = "NEXT_TOTAL_COMMITED";
2 | export const NEXT_INSTRUCTIONS_COMMITED = "NEXT_INSTRUCTIONS_COMMITED";
3 | export const NEXT_UNITS_OCUPATION = "NEXT_UNITS_OCUPATION";
4 | export const NEXT_STATUSES_COUNT = "NEXT_STATUSES_COUNT";
5 | export const NEXT_INSTRUCTIONS_STATUSES_AVERAGE_CYCLES =
6 | "NEXT_INSTRUCTIONS_STATUSES_AVERAGE_CYCLES";
7 | export const SET_CYCLES_PER_REPLICATION = "SET_CYCLES_PER_REPLICATION";
8 |
9 | export function nextInstructionsStatusesAverageCycles(data) {
10 | return {
11 | type: NEXT_INSTRUCTIONS_STATUSES_AVERAGE_CYCLES,
12 | value: data,
13 | };
14 | }
15 |
16 | export function nextStatusesCount(data) {
17 | return {
18 | type: NEXT_STATUSES_COUNT,
19 | value: data,
20 | };
21 | }
22 |
23 | export function nextUnitsUsage(data) {
24 | return {
25 | type: NEXT_UNITS_OCUPATION,
26 | value: data,
27 | };
28 | }
29 |
30 | export function nextTotalCommited(data) {
31 | return {
32 | type: NEXT_TOTAL_COMMITED,
33 | value: data,
34 | };
35 | }
36 |
37 | export function nextInstructionsCommited(data) {
38 | return {
39 | type: NEXT_INSTRUCTIONS_COMMITED,
40 | value: data,
41 | };
42 | }
43 |
44 | export function setCyclesPerReplication(data) {
45 | return {
46 | type: SET_CYCLES_PER_REPLICATION,
47 | value: data,
48 | };
49 | }
50 |
51 | export function clearCyclesPerReplication() {
52 | return {
53 | type: SET_CYCLES_PER_REPLICATION,
54 | value: [],
55 | };
56 | }
57 |
--------------------------------------------------------------------------------
/src/interface/components/Superscalar/JumpPredictionComponent.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import { useTranslation } from 'react-i18next';
3 |
4 | export function JumpPredictionComponent(props) {
5 | const [t, i18n] = useTranslation();
6 |
7 | return (
8 | {this.props.title}
15 |
16 |
38 |
17 | { Object.keys(this.props.data).map(index => (
18 |
37 |
22 |
35 | ))}
36 |
26 | {index}
27 |
28 |
32 | {this.props.data[index]}
33 |
34 |
9 |
34 | );
35 | }
36 |
37 | export default JumpPredictionComponent;
38 |
--------------------------------------------------------------------------------
/src/test/functional/code/nobucle.ts:
--------------------------------------------------------------------------------
1 | export const codeInput = `// SWMDE v1.0
2 | // Autor: Iván Castilla Rodríguez
3 | // Utilidad: Programa de testeo de SWMDE
4 | // Comentarios: El programa presupone q en la posición 50 (R2) de memoria tienes
5 | // un vector de de 16 elementos y quieres sumar a cada elemento una cantidad
6 | // fija (en la posición de memoria 40). El resultado se coloca a partir de la
7 | // posición 70 (R3) de memoria.
8 | // Este fichero es el mismo bucle de "bucle.pla" pero desenrollado totalmente
9 | // (sin bucle)
10 | //
11 | 52
12 | ADDI R2 R0 #50
13 | ADDI R3 R0 #70
14 | ADDI R4 R0 #40
15 | LF F0 (R4)
16 | LF F1 (R2)
17 | LF F2 1(R2)
18 | LF F3 2(R2)
19 | LF F4 3(R2)
20 | LF F5 4(R2)
21 | LF F6 5(R2)
22 | LF F7 6(R2)
23 | LF F8 7(R2)
24 | LF F9 8(R2)
25 | LF F10 9(R2)
26 | LF F11 10(R2)
27 | LF F12 11(R2)
28 | LF F13 12(R2)
29 | LF F14 13(R2)
30 | LF F15 14(R2)
31 | LF F16 15(R2)
32 | ADDF F1 F1 F0
33 | ADDF F2 F2 F0
34 | ADDF F3 F3 F0
35 | ADDF F4 F4 F0
36 | ADDF F5 F5 F0
37 | ADDF F6 F6 F0
38 | ADDF F7 F7 F0
39 | ADDF F8 F8 F0
40 | ADDF F9 F9 F0
41 | ADDF F10 F10 F0
42 | ADDF F11 F11 F0
43 | ADDF F12 F12 F0
44 | ADDF F13 F13 F0
45 | ADDF F14 F14 F0
46 | ADDF F15 F15 F0
47 | ADDF F16 F16 F0
48 | SF F1 (R3)
49 | SF F2 1(R3)
50 | SF F3 2(R3)
51 | SF F4 3(R3)
52 | SF F5 4(R3)
53 | SF F6 5(R3)
54 | SF F7 6(R3)
55 | SF F8 7(R3)
56 | SF F9 8(R3)
57 | SF F10 9(R3)
58 | SF F11 10(R3)
59 | SF F12 11(R3)
60 | SF F13 12(R3)
61 | SF F14 13(R3)
62 | SF F15 14(R3)
63 | SF F16 15(R3)`;
--------------------------------------------------------------------------------
/src/interface/actions/intervals-actions.ts:
--------------------------------------------------------------------------------
1 |
2 | export const ADD_MEMORY_INTERVAL = 'ADD_MEMORY_INTERVAL';
3 | export const REMOVE_MEMORY_INTERVAL = 'REMOVE_MEMORY_INTERVAL';
4 | export const ADD_GENERAL_REGISTERS_INTERVAL = 'ADD_GENERAL_REGISTERS_INTERVAL';
5 | export const REMOVE_GENERAL_REGISTERS_INTERVAL =
6 | 'REMOVE_GENERAL_REGISTERS_INTERVAL';
7 | export const ADD_FLOATING_REGISTERS_INTERVAL =
8 | 'ADD_FLOATING_REGISTERS_INTERVAL';
9 | export const REMOVE_FLOATING_REGISTERS_INTERVAL =
10 | 'REMOVE_FLOATING_REGISTERS_INTERVAL';
11 |
12 |
13 | export function addMemoryInterval(data) {
14 | return {
15 | type: ADD_MEMORY_INTERVAL,
16 | value: data
17 | };
18 | }
19 |
20 | export function addGeneralRegistersInterval(data) {
21 | return {
22 | type: ADD_GENERAL_REGISTERS_INTERVAL,
23 | value: data
24 | };
25 | }
26 |
27 | export function addFloatingRegistersInterval(data) {
28 | return {
29 | type: ADD_FLOATING_REGISTERS_INTERVAL,
30 | value: data
31 | };
32 | }
33 |
34 | export function removeMemoryInterval(data) {
35 | return {
36 | type: REMOVE_MEMORY_INTERVAL,
37 | value: new Set(data)
38 | };
39 | }
40 |
41 | export function removeGeneralRegistersInterval(data) {
42 | return {
43 | type: REMOVE_GENERAL_REGISTERS_INTERVAL,
44 | value: new Set(data)
45 | };
46 | }
47 |
48 | export function removeFloatingRegistersInterval(data) {
49 | return {
50 | type: REMOVE_FLOATING_REGISTERS_INTERVAL,
51 | value: new Set(data)
52 | };
53 | }
54 |
--------------------------------------------------------------------------------
/src/test/functional/code/buclesoft2.ts:
--------------------------------------------------------------------------------
1 | export const codeInput = `// SWMDE v0.1
2 | // Autor: Iván Castilla Rodríguez
3 | // Utilidad: Programa de testeo de SWMDE
4 | // Comentarios: El programa presupone q en la posición 50 (R2) de memoria tienes un vector de
5 | // 16 elementos y quieres sumar a cada elemento una cantidad fija (en la posición de memoria
6 | // 40). El resultado se coloca a partir de la posición 70 (R3) de memoria.
7 | // En este caso, al bucle se le ha aplicado una técnica de Software pipelining., y después se
8 | // ha desenrollado para hacer dos iteraciones en cada pasada
9 | 27
10 | ADDI R2 R0 #50
11 | ADDI R3 R0 #70
12 | ADDI R4 R0 #40
13 | LF F0 (R4)
14 | ADDI R5 R2 #16
15 | // Código de inicialización
16 | LF F1 (R2)
17 | LF F3 1(R2)
18 | ADDF F2 F1 F0
19 | ADDF F4 F3 F0
20 | LF F1 2(R2)
21 | LF F3 3(R2)
22 | ADDI R2 R2 #4
23 | LOOP:
24 | SF F2 (R3)
25 | SF F4 1(R3)
26 | ADDF F2 F1 F0
27 | ADDF F4 F3 F0
28 | LF F1 (R2)
29 | LF F3 1(R2)
30 | ADDI R2 R2 #2
31 | ADDI R3 R3 #2
32 | BNE R2 R5 LOOP
33 | // Código de finalización
34 | SF F2 (R3)
35 | SF F4 1(R3)
36 | ADDF F2 F1 F0
37 | ADDF F4 F3 F0
38 | SF F2 2(R3)
39 | SF F4 3(R3)`;
40 |
41 | export const vliwCodeInput = `20
42 | 2 0 0 0 0 2 0 1 0
43 | 4 1 0 0 0 4 0 1 0 3 4 0 0 5 4 1 0
44 | 1 6 4 0 0
45 | 0
46 | 0
47 | 2 7 2 0 0 9 4 0 0
48 | 2 8 2 0 0 10 4 0 0
49 | 0
50 | 0
51 | 1 11 0 0 0
52 | 4 14 2 0 0 15 2 1 0 12 4 0 0 13 4 1 0
53 | 2 16 4 0 0 17 4 1 0
54 | 0
55 | 1 19 0 0 0
56 | 1 18 0 1 0
57 | 5 23 2 0 2 24 2 1 2 21 4 0 2 22 4 1 2 20 5 0 0 10 1 2
58 | 0
59 | 0
60 | 0
61 | 2 25 4 0 0 26 4 1 0`;
--------------------------------------------------------------------------------
/src/test/functional/code/recorrelista.ts:
--------------------------------------------------------------------------------
1 | export const codeInput = `// Simde v1.2
2 | // Recorre y suma
3 | // Este ejemplo recorre una lista de elementos ordenados por prioridad y suma el valor que
4 | // contienen ponderándolo con la posición en la lista. Cada elemento E de la lista se
5 | // compone de:
6 | // E[0] contiene el valor del elemento
7 | // E[1] contiene 1 si el valor es ponderado o 0 si el valor no se pondera
8 | // E[2] contiene la dirección del siguiente elemento (-1 para fin de la lista)
9 | //
10 | // Registros empleados:
11 | // - R1 apunta al comienzo de la lista (posición 10 de memoria)
12 | // - R2 es el elemento actual
13 | // - R3 apunta al resultado (posición 9)
14 | // - F0 va a contener el contador de la lista (hay que inicializarlo a 0)
15 | // - F1 contiene un 1 en flotante para incrementar el valor de 0
16 | // - F2 contiene el resultado parcial
17 | 19
18 | ADDI R33 R0 #-1
19 | ADDI R1 R0 #10
20 | ADDI R2 R1 #0
21 | ADDI R3 R0 #9
22 | SW R0 (R3)
23 | LF F0 (R3)
24 | LF F2 (R3)
25 | // Inicializo a 1 F1. Para ello uso la posició 1 de memoria como "puente"
26 | ADDI R10 R0 #1
27 | SW R10 1(R0)
28 | LF F1 1(R0)
29 | LOOP:
30 | LF F4 (R2)
31 | LW R4 1(R2)
32 | BEQ R4 R0 NOOP
33 | MULTF F4 F0 F4
34 | NOOP:
35 | ADDF F2 F2 F4
36 | // Incremento el contador de la lista
37 | ADDF F0 F1 F0
38 | LW R2 2(R2)
39 | BNE R2 R33 LOOP
40 | SF F2 (R3)`;
41 |
42 | // lista = [5, 2, 2, 1] resultado = 5 + 2 + 2 + 1*2 = 12
43 | // #14 #17 #20
44 | export const memContent = [5, 0, 14, 0, 2, 0, 17, 2, 0, 20, 1, 1, -1];
--------------------------------------------------------------------------------
/.github/workflows/deploy-pages.yml:
--------------------------------------------------------------------------------
1 | # Simple workflow for deploying static content to GitHub Pages
2 | name: Deploy static content to Pages
3 |
4 | on:
5 | # Runs on pushes targeting the default branch
6 | push:
7 | branches: ['main']
8 |
9 | # Allows you to run this workflow manually from the Actions tab
10 | workflow_dispatch:
11 |
12 | # Sets the GITHUB_TOKEN permissions to allow deployment to GitHub Pages
13 | permissions:
14 | contents: read
15 | pages: write
16 | id-token: write
17 |
18 | # Allow one concurrent deployment
19 | concurrency:
20 | group: 'pages'
21 | cancel-in-progress: true
22 |
23 | jobs:
24 | # Single deploy job since we're just deploying
25 | deploy:
26 | environment:
27 | name: github-pages
28 | url: ${{ steps.deployment.outputs.page_url }}
29 | runs-on: ubuntu-latest
30 | steps:
31 | - name: Checkout
32 | uses: actions/checkout@v4
33 | - name: Setup pnpm
34 | uses: pnpm/action-setup@v4.1.0
35 | - name: Set up Node
36 | uses: actions/setup-node@v4
37 | with:
38 | node-version: 20
39 | cache: pnpm
40 | - name: Install dependencies
41 | run: pnpm install --frozen-lockfile
42 | - name: Build
43 | run: pnpm build
44 | - name: Setup Pages
45 | uses: actions/configure-pages@v5
46 | - name: Upload artifact
47 | uses: actions/upload-pages-artifact@v3
48 | with:
49 | # Upload dist folder
50 | path: './dist'
51 | - name: Deploy to GitHub Pages
52 | id: deployment
53 | uses: actions/deploy-pages@v4
54 |
--------------------------------------------------------------------------------
/src/test/functional/code/bucle4.ts:
--------------------------------------------------------------------------------
1 | export const codeInput = `// SWMDE v1.0
2 | // Autor: Iván Castilla Rodríguez
3 | // Utilidad: Programa de testeo de SWMDE
4 | // Comentarios: El programa presupone q en la posición 50 (R2) de memoria tienes
5 | // un vector de de 16 elementos y quieres sumar a cada elemento una cantidad
6 | // fija (en la posición de memoria 40). El resultado se coloca a partir de la
7 | // posición 70 (R3) de memoria.
8 | // Este fichero es el mismo bucle de "bucle.pla" pero desenrollado para que en
9 | // cada iteración se hagan ocho pasadas del bucle
10 | //
11 | 32
12 | ADDI R2 R0 #50
13 | ADDI R3 R0 #70
14 | ADDI R4 R0 #40
15 | LF F0 (R4)
16 | ADDI R5 R2 #16
17 | LOOP:
18 | LF F1 (R2)
19 | LF F2 1(R2)
20 | LF F3 2(R2)
21 | LF F4 3(R2)
22 | LF F5 4(R2)
23 | LF F6 5(R2)
24 | LF F7 6(R2)
25 | LF F8 7(R2)
26 | ADDF F1 F1 F0
27 | ADDF F2 F2 F0
28 | ADDF F3 F3 F0
29 | ADDF F4 F4 F0
30 | ADDF F5 F5 F0
31 | ADDF F6 F6 F0
32 | ADDF F7 F7 F0
33 | ADDF F8 F8 F0
34 | SF F1 (R3)
35 | SF F2 1(R3)
36 | SF F3 2(R3)
37 | SF F4 3(R3)
38 | SF F5 4(R3)
39 | SF F6 5(R3)
40 | SF F7 6(R3)
41 | SF F8 7(R3)
42 | ADDI R2 R2 #8
43 | ADDI R3 R3 #8
44 | BNE R2 R5 LOOP`;
45 |
46 | export const vliwCodeInput = `18
47 | 2 0 0 0 0 2 0 1 0
48 | 3 1 0 0 0 4 0 1 0 3 4 0 0
49 | 2 5 4 0 0 6 4 1 0
50 | 2 7 4 0 0 8 4 1 0
51 | 2 9 4 0 0 10 4 1 0
52 | 2 11 4 0 0 12 4 1 0
53 | 2 13 2 0 0 14 2 1 0
54 | 2 15 2 0 0 16 2 1 0
55 | 2 17 2 0 0 18 2 1 0
56 | 2 19 2 0 0 20 2 1 0
57 | 2 21 4 0 0 22 4 1 0
58 | 2 23 4 0 0 24 4 1 0
59 | 2 25 4 0 0 26 4 1 0
60 | 2 27 4 0 0 28 4 1 0
61 | 1 29 0 0 0
62 | 0
63 | 1 31 5 0 0 2 1 2
64 | 1 30 0 0 0`;
--------------------------------------------------------------------------------
/src/interface/actions/reserve-station-actions.ts:
--------------------------------------------------------------------------------
1 | export const NEXT_RESERVE_STATION_CYCLE = 'NEXT_RESERVE_STATION_CYCLE';
2 |
3 | export function nextReserveStationCycle(data) {
4 | return {
5 | type: NEXT_RESERVE_STATION_CYCLE,
6 | value: data.map(element => mapReserveStationEntry(element))
7 | };
8 | }
9 |
10 | function mapReserveStationEntry(content: { data: any, size: number }): any {
11 | let data = content.data;
12 | let toReturn = [];
13 | let i;
14 |
15 | const defaultObject = {
16 | instruction: { id: '', value: '', uid: '' },
17 | Qj: '',
18 | Vj: '',
19 | Qk: '',
20 | Vk: '',
21 | A: '',
22 | ROB: ''
23 | };
24 | for (i = 0; i < data.length; i++) {
25 | let aux = { ...defaultObject };
26 | if (data[i] != null) {
27 | aux = {
28 | instruction: { id: '', value: '', uid: '' },
29 | Qj: data[i].Qj,
30 | Vj: data[i].Vj,
31 | Qk: data[i].Qk,
32 | Vk: data[i].Vk,
33 | A: data[i].A,
34 | ROB: data[i].ROB
35 | };
36 | if (data[i].instruction != null) {
37 | aux.instruction.id = data[i].instruction.id;
38 | aux.instruction.value = data[i].instruction.value;
39 | aux.instruction.uid = data[i].instruction.uid;
40 | }
41 | }
42 |
43 | toReturn.push(aux);
44 | }
45 |
46 | for (let j = i; j < content.size; j++) {
47 | toReturn.push({ ...defaultObject });
48 | }
49 | return toReturn;
50 | }
51 |
--------------------------------------------------------------------------------
/docs/en/ventana-registros-memoria.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: en
4 | id: ventana-registros-memoria
5 | title: Register and Memory Window
6 | next: en/ventana-simulacion.html
7 | prev: en/configurar-parametros-superescalar.html
8 | ---
9 |
10 | There are two different ways for showing General Purpose or Floating Point Registers and Memory:
11 |
12 | 1. Click on menu Execute => Components and select a component.
13 |
14 | 2. Use the components combo box from the Execution Tool Bar.
15 |
16 |
17 | 
18 |
19 | This window allows the user to see a subset of registers (or memory positions) of the current component.
20 |
21 | The first column shows the register index or memory position. The second one shows the value associated to this index/position (floating point values are rounded to 3 decimals).
22 |
23 | There are a set of buttons below the window :
24 |
25 |  Click this button to select a subset of registers/positions to show. The selection is making by using a comma-separated list of numbers or intervals (for example: 2,10-15,20).
26 |
27 |  Click this button to select a subset of registers/positions to hide. The selection is making by using a comma-separated list of numbers or intervals (for example: 2,10-15,20).
28 |
29 |  Click this button to save the changes made in the component.
30 |
31 |  Click this button to cancel the changes made in the component.
32 |
33 |  Reset all selected values.
34 |
--------------------------------------------------------------------------------
/docs/es/fichero-de-codigo-secuencial.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: es
4 | id: fichero-de-codigo-secuencial
5 | title: Fichero de código secuencial
6 | prev: ventana-simulacion.html
7 | next: ejemplo-de-codigo-secuencial.html
8 | ---
9 |
10 | Los Ficheros de Código Secuencial que se emplean como entrada permiten definir de forma sencilla un código secuencial mediante cualquier editor de textos. Todos los ficheros de código deben llevar la extensión .pla
11 |
12 |
13 | ## Características
14 |
15 | El fichero debe cumplir las siguientes características:
16 | * La primera línea del fichero (que no sea un comentario) contiene el número de instrucciones del fichero.
17 | * Cada instrucción debe ponerse en una nueva línea.
18 | * Se permiten como separadores de operandos tabuladores o espacios.
19 | * Las etiquetas se ponen al principio de la línea y deben terminar con ":".
20 | * Los comentarios se indican con "//". De ahí al final de la línea todo es un comentario.
21 |
22 |
23 | ## Instrucciones
24 |
25 | Las instrucciones permitidas están inspiradas en el repertorio MIPS IV. Se emplea la siguiente nomenclatura:
26 |
27 | * Rn Registro de Propósito General n.
28 | Ej. R1, R0...
29 | * Fm Registro de Punto Flotante m.
30 | Ej. F1, F0...
31 | * #n Valor inmediato n.
32 | Ej. #12, #0...
33 | * n(Rm) Dirección de memoria.
34 | Ej. (R1), 3(R4)...
35 | * LAB: Etiqueta destino de un salto.
36 | Ej. LOOP1:, END:...
37 |
38 |
39 | Las instrucciones permitidas son:
40 | * ADDI Rn Rm #i
41 | * ADD Rn Rm Rp
42 | * MULT Rn Rm Rp
43 | * ADDF Fn Fm Fp
44 | * MULTF Fn Fm Fp
45 | * LW Rn i(Rm)
46 | * LF Fn i(Rm)
47 | * SW Rn i(Rm)
48 | * SF Fn i(Rm)
49 | * BNE Rn Rm LAB
50 | * BEQ Rn Rm LAB
51 |
--------------------------------------------------------------------------------
/docs/es/ventana-registros-memoria.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: es
4 | id: ventana-registros-memoria
5 | title: Ventana de Registros - Memoria
6 | next: ventana-simulacion.html
7 | prev: configurar-parametros-superescalar.html
8 | ---
9 |
10 |
11 | Para ver los Registros de Propósito General, los de Punto Flotante o la Memoria se pueden emplear dos métodos:
12 |
13 | 1. Ir al menú Ejecutar => Maquina Superescalar/VLIW => Componentes y elegir el componente correspondiente.
14 |
15 | 2. Desde la Barra de Herramientas de Ejecución usar el cuadro combinado de componentes.
16 |
17 |
18 | 
19 | La ventana permite ver un subconjunto de los elementos del componente seleccionado por el usuario.
20 |
21 | La primera columna representa el índice o la posición, y la segunda columna representa el valor de esa posición (por claridad, los números en punto flotante se presentan siempre redondeados a 3 decimales).
22 |
23 | Se presentan una serie de botones en la parte baja de la ventana:
24 |
25 |  Permite seleccionar un subconjunto de elementos para mostrar mediante una lista de números o intervalos separados por comas (ej. 2,10-15,20).
26 |
27 | Permite seleccionar un subconjunto de elementos para ocultar mediante una lista de números o intervalos separados por comas (ej. 2,10-15,20).
28 |
29 |  Guarda los cambios realizados en el contenido del componente.
30 |
31 |  Cancela los cambios realizados en el contenido del componente.
32 |
33 |  Pone todos los elementos seleccionados a 0.
34 |
--------------------------------------------------------------------------------
/docs/en/fichero-de-codigo-secuencial.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: en
4 | id: fichero-de-codigo-secuencial
5 | title: Sequential Code File
6 | prev: en/ventana-simulacion.html
7 | next: en/ejemplo-de-codigo-secuencial.html
8 | ---
9 |
10 | The input sequential code files allows the user to easily define a sequential code with any text editor. The .pla extension is required for all code files.
11 |
12 |
13 | ### Characteristics
14 |
15 | File must be created with the following characteristics:
16 | * The first line (not a commentary) must contain the number of instructions of code.
17 | * Each instruction must be placed in a new line.
18 | * Operands are separated with blanks or tabs.
19 | * Labels must be placed at the start of the line and always finishes with a ":".
20 | * Commentaries start with "//". From here to the end of the line will be considered as a commentary.
21 |
22 |
23 | ### Instructions
24 |
25 | The instructions are inspired in the MIPS IV repertory. We use the next nomenclature:
26 |
27 | * Rn General Purpose Register n.
28 | f. i. R1, R0...
29 | * Fm Floating Point Register m.
30 | f. i. F1, F0...
31 | * #n Inmediate value n.
32 | f. i. #12, #0...
33 | * n(Rm) Memory address.
34 | f. i. (R1), 3(R4)...
35 | * LAB: Branch destiny label.
36 | f. i. LOOP1:, END:...
37 |
38 |
39 | The allowed instructions are:
40 | * ADDI Rn Rm #i
41 | * ADD Rn Rm Rp
42 | * SUB Rn Rm Rp
43 | * AND Rn Rm Rp
44 | * OR Rn Rm Rp
45 | * NOR Rn Rm Rp
46 | * XOR Rn Rm Rp
47 | * SLLV Rn Rm Rp
48 | * SRLV Rn Rm Rp
49 | * MULT Rn Rm Rp
50 | * ADDF Fn Fm Fp
51 | * SUBF Fn Fm Fp
52 | * MULTF Fn Fm Fp
53 | * LW Rn i(Rm)
54 | * LF Fn i(Rm)
55 | * SW Rn i(Rm)
56 | * SF Fn i(Rm)
57 | * BNE Rn Rm LAB
58 | * BEQ Rn Rm LAB
59 | * BGT Rn Rm LAB
--------------------------------------------------------------------------------
/docs/es/juego-de-instrucciones.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: es
4 | id: juego-de-instrucciones
5 | title: Juego de instrucciones
6 | prev: estructura-comun.html
7 | next: memoria.html
8 | ---
9 |
10 | El Juego de Instrucciones (Operaciones en la máquina VLIW) es común a las dos máquinas. Sin embargo hay ligeras diferencias en el comportamiento de algunas de las instrucciones.
11 |
12 | ADDI
13 | Suma Entera con Inmediato sin signo
14 | ADDI Rd, Ro1, #Inm
15 | Rd = Ro1 + Inm
16 | Se opera en la UF de Suma Entera
17 |
18 | ADD
19 | Suma Entera
20 | ADD Rd, Ro1, Ro2
21 | Rd = Ro1 + Ro2
22 | Se opera en la UF de Suma Entera
23 |
24 | MULT
25 | Multiplicación Entera
26 | MULT Rd, Ro1, Ro2
27 | Rd = Ro1 * Ro2
28 | Se opera en la UF de Multiplicación Entera
29 |
30 | ADDF
31 | Suma Punto Flotante
32 | ADDF Fd, Fo1, Fo2
33 | Fd = Fo1 + Fo2
34 | Se opera en la UF de Suma en Punto Flotante
35 |
36 | MULTF
37 | Multiplicación Punto Flotante
38 | MULTF Fd, Fo1, Fo2
39 | Fd = Fo1 * Fo2
40 | Se opera en la UF de Multiplicación en Punto Flotante
41 |
42 | LW
43 | Load Entero
44 | LW Rd, Inm(Ro)
45 | Rd = MEM[Ro + Inm]
46 | Se opera en la UF de Memoria
47 |
48 | LF
49 | Load Flotante
50 | LF Fd, Inm(Ro)
51 | Fd = MEM[Ro + Inm]
52 | Se opera en la UF de Memoria
53 |
54 | SW
55 | Store Entero
56 | SW Ro, Inm(Rd)
57 | MEM[Rd + Inm] = Ro
58 | Se opera en la UF de Memoria
59 |
60 | SF
61 | Store Flotante
62 | SF Fo, Inm(Rd)
63 | MEM[Rd + Inm] = Fo
64 | Se opera en la UF de Memoria
65 |
66 | BNE
67 | Salta si distinto
68 | BNE Ro1, Ro2, Etiqueta
69 | Si (Ro1 != Ro2)
70 | Saltar a instrucción apuntada por Etiqueta
71 | Se opera en la UF de Salto
72 |
73 | BEQ
74 | Salta si igual
75 | BEQ Ro1, Ro2, Etiqueta
76 | Si (Ro1 == Ro2)
77 | Saltar a instrucción apuntada por Etiqueta
78 | Se opera en la UF de Salto
--------------------------------------------------------------------------------
/src/interface/styles/components/GeneralTabComponent.scss:
--------------------------------------------------------------------------------
1 | @import '../base/variables';
2 |
3 |
4 | .smd-general_tab {
5 | width: 100%;
6 | height: 100%;
7 | display: flex;
8 |
9 | &-code {
10 | width: 25%;
11 | }
12 |
13 | &-simulation {
14 | width: 75%;
15 | display: flex;
16 |
17 | &_left {
18 | width: 40%;
19 | height: 100%;
20 |
21 | &--expanded {
22 | width: 80%;
23 | height: 100%;
24 |
25 | & .smd-general_tab-simulation_planificator {
26 | height: 70%;
27 |
28 | & .smd-table-header_title {
29 | width: 8.3%;
30 |
31 | }
32 |
33 | & .id_colum {
34 | width: 5%;
35 | }
36 | }
37 | }
38 | }
39 |
40 | &_center {
41 | width: 40%;
42 | height: 100%;
43 | }
44 |
45 | &_right {
46 | width: 20%;
47 | }
48 |
49 | &_nat_predicate {
50 | display: flex;
51 | width: 100%;
52 | height: 30%;
53 | flex: 1 0 auto;
54 |
55 | & .smd-register {
56 | width: 100%;
57 | height: 100%;
58 | }
59 | }
60 |
61 | &_prefetch_decoder {
62 | height: 25%;
63 | display: flex;
64 | }
65 |
66 | &_mappers {
67 | height: 25%;
68 | display: flex;
69 | }
70 |
71 | &_register_mapper {
72 | flex: 1 0 auto;
73 | }
74 |
75 | &_reorder_buffer {
76 | height: 50%;
77 | }
78 | }
79 | }
80 |
--------------------------------------------------------------------------------
/src/interface/reducers/interval.ts:
--------------------------------------------------------------------------------
1 | export function addInterval(state, field, interval) {
2 |
3 | const newVisibleRangeValues = Array.from(
4 | new Set([...state[field].visibleRangeValues, ...interval])
5 | ).sort((a, b) => +a - +b);
6 |
7 | let newState = {
8 | ...state,
9 | history : state.history.map(historyEntry => {
10 | const newHistoryEntry = {
11 | ...historyEntry
12 | };
13 | newHistoryEntry[field] = {
14 | ...historyEntry[field],
15 | visibleRangeValues: newVisibleRangeValues
16 | };
17 | return newHistoryEntry;
18 | })
19 | };
20 | newState[field] = {
21 | ...state[field],
22 | visibleRangeValues: Array.from(
23 | new Set([...state[field].visibleRangeValues, ...interval])
24 | ).sort((a, b) => +a - +b)
25 | };
26 |
27 | return newState;
28 | }
29 |
30 | export function removeInterval(state, field, interval) {
31 | const newVisibleRangeValues = state[field].visibleRangeValues.filter(
32 | x => !interval.has(x)
33 | );
34 | let newState = {
35 | ...state,
36 | history : state.history.map(historyEntry => {
37 | const newHistoryEntry = {
38 | ...historyEntry
39 | };
40 | newHistoryEntry[field] = {
41 | ...historyEntry[field],
42 | visibleRangeValues: newVisibleRangeValues
43 | };
44 | return newHistoryEntry;
45 | })
46 | };
47 |
48 | newState[field] = {
49 | ...state[field],
50 | visibleRangeValues: state[field].visibleRangeValues.filter(
51 | x => !interval.has(x)
52 | )
53 | };
54 |
55 | return (state = newState);
56 | }
57 |
--------------------------------------------------------------------------------
/docs/en/menu-configurar.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: en
4 | id: menu-configurar
5 | title: Config menu
6 | prev: en/menu-ver.html
7 | next: en/menu-ejecutar.html
8 | ---
9 |
10 | This menu contains utilities to configure processor parameters.
11 |
12 |
13 | ## Superscalar Configuration
14 |
15 | Use this menu item to show the Superscalar Configuration window, that allows to modify the main parameters of the superscalar processor.
16 |
17 |
18 | ## VLIW Configuration
19 |
20 | Use this menu item to show the VLIW Configuration window, that allows to modify the main parameters of the VLIW processor.
21 |
22 |
23 | ## Memory-Registers data
24 |
25 | This menu item allows to load/save the contents of memory and registers from/to a file:
26 |
27 | * Save Mem/Reg to File: Allows the user to save the contents of the memory and registers of the superscalar or the VLIW processor to a file.
28 | * Load Mem/Reg from File: Allows the user to load the contents of the memory and the registers from a file. The user is asked in order to fill only the superscalar processor, only the VLIW one or both.
29 |
30 |
31 | ## VLIW Instructions
32 |
33 | This menu contains some useful options in order to design a VLIW code:
34 |
35 | * Create New VLIW Code: Use this menu item to create a blank VLIW code.
36 | * Load VLIW Code...: Use this menu item to load a VLIW code from a file.
37 |
38 |
39 | ## Options
40 |
41 | This menu contains some general options:
42 |
43 | * Reset Processor at start: If this option is marked the registers and memory are reset every time you start a new simulation. Otherwise, the values are perserved.
44 | * Check VLIW Code: If this option is marked every new VLIW code is checked looking for errors.
45 | * % Data Cache Miss: Use this option to set the data cache miss rate when you use a LOAD instruction. Use 0 for no misses and 100 for direct main memory access.
--------------------------------------------------------------------------------
/src/interface/actions/functional-unit-actions.ts:
--------------------------------------------------------------------------------
1 | import { FunctionalUntitVisualEntry } from "../../core/Common/FunctionalUnit";
2 |
3 | export const FUNCTIONAL_UNIT_CYCLE = 'FUNCTIONAL_UNIT_CYCLE';
4 |
5 | export function nextFunctionalUnitCycle(data) {
6 | return {
7 | type: FUNCTIONAL_UNIT_CYCLE,
8 | value: data.map(element => mapFunctionalUnitData(element))
9 | };
10 | }
11 | function mapFunctionalUnitData(data): any {
12 | let toReturnObject = {
13 | content: [],
14 | header: []
15 | };
16 | let content = new Array();
17 | if (data != null && data[0] != null) {
18 | let aux = [];
19 | for (let j = 0; j < data.length; j++) {
20 | let instrsEntries: FunctionalUntitVisualEntry[] = data[j].getVisualData();
21 |
22 | for (let entry of instrsEntries) {
23 | if (entry.id !== -1) {
24 | aux.push({
25 | id: entry.id,
26 | value: entry.value,
27 | uid: entry.uid,
28 | color: ''
29 | });
30 | } else {
31 | aux.push({
32 | id: '-',
33 | value: '',
34 | uid: -1,
35 | color: ''
36 | });
37 | }
38 | }
39 | }
40 | content.push(aux);
41 |
42 | }
43 | toReturnObject.content = content;
44 | toReturnObject.header = generateFunctionalUnitHeader(data);
45 | return toReturnObject;
46 | }
47 |
48 | function generateFunctionalUnitHeader(data): string[] {
49 | let toReturn = [];
50 | if (data != null) {
51 | for (let i = 0; i < data.length; i++) {
52 | toReturn.push(`#${i}`);
53 | }
54 | }
55 | return toReturn;
56 | }
57 |
--------------------------------------------------------------------------------
/docs/en/barra-de-herramientas-estandar.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | lang: en
4 | id: barra-de-herramientas-estandar
5 | title: Standard Tool Bar
6 | prev: en/menu-ayuda.html
7 | next: en/barra-de-herramientas-de-ejecucion.html
8 | ---
9 |
10 | This tool bar contains general options.
11 |
12 |  Click this button to open a sequential code file.
13 |
14 |  Permite abrir un fichero con código secuencial.
15 |
16 |  Habilita la opción de colorear los bloques básicos en el código.
17 |
18 |  Muestra/oculta el código secuencial cargado de fichero.
19 |
20 |  Abre la ventana de Configuración de la Máquina Superescalar, con la que se pueden modificar sus parámetros más importantes.
21 |
22 |  Abre la ventana de Configuración de la Máquina VLIW, con la que se pueden modificar sus parámetros más importantes.
23 |
24 |  Permite establecer el porcentaje de fallos de caché de datos al realizar una instrucción de carga (LOAD). 0 significa que no habrá ningún fallo y 100 significa que todos los accesos producen fallo.
25 |
26 | {bml bm2.BMP} Click this button to open a sequential code file.
27 |
28 | {bml bm3.BMP} Click this button to colour the basic blocks in code window.
29 |
30 | {bml bm4.BMP} Click this button to show/hide the sequential code loaded from a file.
31 |
32 | {bml bm5.BMP} Click this button to open the Superscalar Configuration window.
33 |
34 | {bml bm6.BMP} Click this button to open the VLIW Configuration window.
35 |
36 | {bml bm7.BMP} Click this button to set the data cache miss rate when you use a LOAD instruction. Use 0 for no misses and 100 for direct main memory access.
37 |
38 | {bml bm8.BMP} Click this button to create a blank VLIW code.
39 |
40 | {bml bm9.BMP} Click this button to load a VLIW code from a file.
--------------------------------------------------------------------------------
/docs/_book/gitbook/gitbook-plugin-lunr/search-lunr.js:
--------------------------------------------------------------------------------
1 | require([
2 | 'gitbook',
3 | 'jquery'
4 | ], function(gitbook, $) {
5 | // Define global search engine
6 | function LunrSearchEngine() {
7 | this.index = null;
8 | this.store = {};
9 | this.name = 'LunrSearchEngine';
10 | }
11 |
12 | // Initialize lunr by fetching the search index
13 | LunrSearchEngine.prototype.init = function() {
14 | var that = this;
15 | var d = $.Deferred();
16 |
17 | $.getJSON(gitbook.state.basePath+'/search_index.json')
18 | .then(function(data) {
19 | // eslint-disable-next-line no-undef
20 | that.index = lunr.Index.load(data.index);
21 | that.store = data.store;
22 | d.resolve();
23 | });
24 |
25 | return d.promise();
26 | };
27 |
28 | // Search for a term and return results
29 | LunrSearchEngine.prototype.search = function(q, offset, length) {
30 | var that = this;
31 | var results = [];
32 |
33 | if (this.index) {
34 | results = $.map(this.index.search(q), function(result) {
35 | var doc = that.store[result.ref];
36 |
37 | return {
38 | title: doc.title,
39 | url: doc.url,
40 | body: doc.summary || doc.body
41 | };
42 | });
43 | }
44 |
45 | return $.Deferred().resolve({
46 | query: q,
47 | results: results.slice(0, length),
48 | count: results.length
49 | }).promise();
50 | };
51 |
52 | // Set gitbook research
53 | gitbook.events.bind('start', function(e, config) {
54 | var engine = gitbook.search.getEngine();
55 | if (!engine) {
56 | gitbook.search.setEngine(LunrSearchEngine, config);
57 | }
58 | });
59 | });
60 |
--------------------------------------------------------------------------------
/.all-contributorsrc:
--------------------------------------------------------------------------------
1 | {
2 | "projectName": "SIMDE",
3 | "projectOwner": "SIMDE-ULL",
4 | "files": [
5 | "README.md"
6 | ],
7 | "commitType": "docs",
8 | "commitConvention": "angular",
9 | "contributorsPerLine": 7,
10 | "contributors": [
11 | {
12 | "login": "icasrod",
13 | "name": "Iván Castilla Rodríguez",
14 | "avatar_url": "https://avatars.githubusercontent.com/u/17193911?v=4",
15 | "profile": "https://github.com/icasrod",
16 | "contributions": [
17 | "research",
18 | "projectManagement",
19 | "mentoring",
20 | "ideas",
21 | "example",
22 | "doc"
23 | ]
24 | },
25 | {
26 | "login": "adrianabreu",
27 | "name": "Adrian Abreu Gonzalez",
28 | "avatar_url": "https://avatars.githubusercontent.com/u/9080392?v=4",
29 | "profile": "https://adrianabreu.gitlab.io",
30 | "contributions": [
31 | "platform",
32 | "design"
33 | ]
34 | },
35 | {
36 | "login": "alu0100884012",
37 | "name": "alu0100884012",
38 | "avatar_url": "https://avatars.githubusercontent.com/u/22546849?v=4",
39 | "profile": "https://github.com/alu0100884012",
40 | "contributions": [
41 | "platform"
42 | ]
43 | },
44 | {
45 | "login": "oxcabe",
46 | "name": "Óscar Carrasco",
47 | "avatar_url": "https://avatars.githubusercontent.com/u/25517190?v=4",
48 | "profile": "http://oxca.be",
49 | "contributions": [
50 | "mentoring",
51 | "maintenance",
52 | "platform"
53 | ]
54 | },
55 | {
56 | "login": "endes0",
57 | "name": "endes0",
58 | "avatar_url": "https://avatars.githubusercontent.com/u/5920682?v=4",
59 | "profile": "https://github.com/endes0",
60 | "contributions": [
61 | "test",
62 | "maintenance"
63 | ]
64 | }
65 | ]
66 | }
67 |
--------------------------------------------------------------------------------
/src/interface/utils/interval.ts:
--------------------------------------------------------------------------------
1 | export function generateIntervalFromImput(input: string, max: number): number[] {
2 |
3 | let newInterval = new Set{t(props.title)}
10 |
11 |
33 |
12 | {props.jumpPrediction.map((row, i) => (
13 |
32 |
17 |
30 | ))}
31 |
21 | {i}
22 |
23 |
27 | {row}
28 |
29 |
11 |
37 | );
38 | }
39 |
40 | export default ProjectPage;
41 |
--------------------------------------------------------------------------------
/src/interface/actions/predicate-nat-actions.ts:
--------------------------------------------------------------------------------
1 | export const NEXT_NAT_FPR_CYCLE = 'NEXT_NAT_FPR_CYCLE';
2 | export const NEXT_NAT_GPR_CYCLE = 'NEXT_NAT_GPR_CYCLE';
3 | export const NEXT_PREDICATE_CYCLE = 'NEXT_PREDICATE_CYCLE';
4 |
5 | export const ADD_NAT_FPR_INTERVAL = 'ADD_NAT_FPR_INTERVAL';
6 | export const ADD_NAT_GPR_INTERVAL = 'ADD_NAT_GPR_INTERVAL';
7 | export const REMOVE_NAT_FPR_INTERVAL = 'REMOVE_NAT_FPR_INTERVAL';
8 | export const REMOVE_NAT_GPR_INTERVAL = 'REMOVE_NAT_GPR_INTERVAL';
9 | export const ADD_PREDICATE_INTERVAL = 'ADD_PREDICATE_INTERVAL';
10 | export const REMOVE_PREDICATE_INTERVAL = 'REMOVE_PREDICATE_INTERVAL';
11 |
12 | export function addNatFprInterval(data) {
13 | return {
14 | type: ADD_NAT_FPR_INTERVAL,
15 | value: data
16 | };
17 | }
18 |
19 | export function addNatGprInterval(data) {
20 | return {
21 | type: ADD_NAT_GPR_INTERVAL,
22 | value: data
23 | };
24 | }
25 |
26 | export function removeNatFprInterval(data) {
27 | return {
28 | type: REMOVE_NAT_FPR_INTERVAL,
29 | value: new Set(data)
30 | };
31 | }
32 |
33 | export function removeNatGprInterval(data) {
34 | return {
35 | type: REMOVE_NAT_GPR_INTERVAL,
36 | value: new Set(data)
37 | };
38 | }
39 |
40 | export function addMemoryInterval(data) {
41 | return {
42 | type: ADD_PREDICATE_INTERVAL,
43 | value: data
44 | };
45 | }
46 |
47 | export function removeMemoryInterval(data) {
48 | return {
49 | type: REMOVE_PREDICATE_INTERVAL,
50 | value: new Set(data)
51 | };
52 | }
53 |
54 | export function nextNatFprCycle(data) {
55 | return {
56 | type: NEXT_NAT_FPR_CYCLE,
57 | value: data
58 | };
59 | }
60 |
61 | export function nextNatGprCycle(data) {
62 | return {
63 | type: NEXT_NAT_GPR_CYCLE,
64 | value: data
65 | };
66 | }
67 |
68 | export function nextPredicateCycle(data) {
69 | return {
70 | type: NEXT_PREDICATE_CYCLE,
71 | value: data
72 | };
73 | }
74 |
--------------------------------------------------------------------------------
12 |
19 | -
13 |
{t('landingPage.pagetitle')}
15 | - {t('landingPage.home')} 16 |
- {t('landingPage.project')} 17 |
14 |
20 | 
22 |
33 |
36 | {t('projectPage.pagetitle')}
21 |{t('projectPage.watsimde')}
23 |{t('projectPage.simdedescription1')}
24 |{t('projectPage.simdedescription2')}
25 |{t('projectPage.simdedescription3')}
26 |{t('projectPage.tecnology')}
27 |{t('projectPage.tecnologydescription')}
28 |{t('projectPage.howtouse')}
29 |{t('projectPage.howtousedescription')}
30 |{t('projectPage.problems')}
31 |{t('projectPage.problemsdescription')}
32 |