Skip to content

future program

0) Lecture Notes *

1)  Modify GCC to compile to our processor’s assembly

2) Extend LCC compiler to mammal. Use flex and Bison (or awk) to simplify the design. ** :

3) Read Atari source code. Convert it to C. Adapt it to our system. ***

4) Activating SDRAM on DE0-nano board. Add the necessary wait states to our processor.

5) Design a USB interface

6) Design a Sprite graphics system and associated graphics chips..

7) Reading Risc-V / RocketChip source code.

8) Using what is learned from (6) to design for cache+paging+privileges.

9) Run two programs which have the same address space to see if paging works.

10) Adapt linux 0.11 to our system.

11) Design a GUI.

12) If possible, write also a LLVM compiler

<!doctype html>
      <canvas width = "500" height = "300" id = "my_Canvas"></canvas>
         /* Step1: Prepare the canvas and get WebGL context */

         var canvas = document.getElementById('my_Canvas');
         var gl = canvas.getContext('experimental-webgl');

         /* Step2: Define the geometry and store it in buffer objects */

         var vertices = [-0.5, 0.5, -0.5, -0.5, 0.0, -0.5,];

         // Create a new buffer object
         var vertex_buffer = gl.createBuffer();

         // Bind an empty array buffer to it
//WebGL lets us manipulate many WebGL resources on global bind points. You can think of bind points as 
//internal global variables inside WebGL. First you bind a resource to a bind point. Then, all other functions 
//refer to the resource through the bind point. So, let's bind the position buffer.
         gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer);
         // Pass the vertices data to the buffer
         gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);

         // Unbind the buffer
         gl.bindBuffer(gl.ARRAY_BUFFER, null);

         /* Step3: Create and compile Shader programs */

         // Vertex shader source code
         var vertCode =
            'attribute vec2 coordinates;' + 
            'void main(void) {' + ' gl_Position = vec4(coordinates,0.0, 1.0);' + '}';

         //Create a vertex shader object
         var vertShader = gl.createShader(gl.VERTEX_SHADER);

         //Attach vertex shader source code
         gl.shaderSource(vertShader, vertCode);

         //Compile the vertex shader

         //Fragment shader source code
         var fragCode = 'void main(void) {' + 'gl_FragColor = vec4(0.0, 0.0, 0.0, 0.1);' + '}';

         // Create fragment shader object
         var fragShader = gl.createShader(gl.FRAGMENT_SHADER);

         // Attach fragment shader source code
         gl.shaderSource(fragShader, fragCode);

         // Compile the fragment shader

         // Create a shader program object to store combined shader program
         var shaderProgram = gl.createProgram();

         // Attach a vertex shader
         gl.attachShader(shaderProgram, vertShader); 
         // Attach a fragment shader
         gl.attachShader(shaderProgram, fragShader);

         // Link both programs

         // Use the combined shader program object -- send to gpu

         /* Step 4: Associate the shader programs to buffer objects */

         //Bind vertex buffer object
         gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer);

         //Get the attribute location
         var coord = gl.getAttribLocation(shaderProgram, "coordinates");

         //point an attribute to the currently bound VBO
         gl.vertexAttribPointer(coord, 2, gl.FLOAT, false, 0, 0);

         //Enable the attribute

         /* Step5: Drawing the required object (triangle) */

         // Clear the canvas
         gl.clearColor(0.5, 0.5, 0.5, 0.9);

         // Enable the depth test
         // Clear the color buffer bit

         // Set the view port

         // Draw the triangle
         gl.drawArrays(gl.TRIANGLES, 0, 3);


import torch
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

class CustomDataset:
  def __init__(self, data, targets):
  def __len__(self):
    return len(
  def __getitem__(self, idx):
    current_sample =[idx,:]
    current_target = self.targets[idx]
        "x": torch.tensor(current_sample, dtype=torch.float),
        "y": torch.tensor(current_target, dtype=torch.long)

data, targets =  make_classification(n_samples = 1000)   
train_data, test_data, train_targets, test_targets = train_test_split(data, targets, stratify=targets) # stratify keeps no of pve and nve samples same.
train_dataset = CustomDataset(train_data, train_targets)
test_dataset = CustomDataset(test_data, test_targets)
train_loader  =, batch_size=4, num_workers=2 )
test_loader  =, batch_size=4, num_workers=2 )

#for data in test_loader:
#		print(data)    
#		break

model = lambda x, w, b: torch.matmul(x,w) + b
W = torch.randn(20,1,requires_grad=True)
b = torch.randn(1,requires_grad=True)
learning_rate = 0.001

for epoch in range(10):
  epoch_loss = 0
  for data in train_loader:
    xtrain = data["x"]
    ytrain = data["y"]
    output = model(xtrain,W,b)
    loss = torch.mean((ytrain.view(-1)-output.view(-1))**2)
    epoch_loss = epoch_loss + loss.item()
    with torch.no_grad():
      W = W - learning_rate*W.grad
      b = b - learning_rate*b.grad
  print(epoch, epoch_loss)

outputs =[]
with torch.no_grad():
   for data in test_loader
       xtest = data["x"]
       ytest = data["y"]
       output = model(xtest,W,b)

(   , )
A simple walkthrough of how to code a fully connected neural network
using the PyTorch library. For demonstration we train it on the very
common MNIST dataset of handwritten digits. In this code we go through
how to create the network as well as initialize a loss function, optimizer,
check accuracy and more.
Programmed by Aladdin Persson
* 2020-04-08: Initial coding
* 2021-03-24: Added more detailed comments also removed part of
              check_accuracy which would only work specifically on MNIST.
* 2022-09-23: Updated with more detailed comments, docstrings to functions, and checked code still functions as intended.

# Imports
import torch
import torchvision # torch package for vision related things
import torch.nn.functional as F  # Parameterless functions, like (some) activation functions
import torchvision.datasets as datasets  # Standard datasets
import torchvision.transforms as transforms  # Transformations we can perform on our dataset for augmentation
from torch import optim  # For optimizers like SGD, Adam, etc.
from torch import nn  # All neural network modules
from import DataLoader  # Gives easier dataset managment by creating mini batches etc.
from tqdm import tqdm  # For nice progress bar!

# Here we create our simple neural network. For more details here we are subclassing and
# inheriting from nn.Module, this is the most general way to create your networks and
# allows for more flexibility. I encourage you to also check out nn.Sequential which
# would be easier to use in this scenario but I wanted to show you something that
# "always" works and is a general approach.
class NN(nn.Module):
    def __init__(self, input_size, num_classes):
        Here we define the layers of the network. We create two fully connected layers
            input_size: the size of the input, in this case 784 (28x28)
            num_classes: the number of classes we want to predict, in this case 10 (0-9)
        super(NN, self).__init__()
        # Our first linear layer take input_size, in this case 784 nodes to 50
        # and our second linear layer takes 50 to the num_classes we have, in
        # this case 10.
        self.fc1 = nn.Linear(input_size, 50)
        self.fc2 = nn.Linear(50, num_classes)

    def forward(self, x):
        x here is the mnist images and we run it through fc1, fc2 that we created above.
        we also add a ReLU activation function in between and for that (since it has no parameters)
        I recommend using nn.functional (F)
            x: mnist images
            out: the output of the network

        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Set device cuda for GPU if it's available otherwise run on the CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Hyperparameters
input_size = 784
num_classes = 10
learning_rate = 0.001
batch_size = 64
num_epochs = 3

# Load Data
train_dataset = datasets.MNIST(root="dataset/", train=True, transform=transforms.ToTensor(), download=True)
test_dataset = datasets.MNIST(root="dataset/", train=False, transform=transforms.ToTensor(), download=True)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)

# Initialize network
model = NN(input_size=input_size, num_classes=num_classes).to(device)

# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Train Network
for epoch in range(num_epochs):
    for batch_idx, (data, targets) in enumerate(tqdm(train_loader)):
        # Get data to cuda if possible
        data =
        targets =

        # Get to correct shape
        data = data.reshape(data.shape[0], -1)

        # Forward
        scores = model(data)
        loss = criterion(scores, targets)

        # Backward

        # Gradient descent or adam step

# Check accuracy on training & test to see how good our model
def check_accuracy(loader, model):
    Check accuracy of our trained model given a loader and a model
            A loader for the dataset you want to check accuracy on
        model: nn.Module
            The model you want to check accuracy on
        acc: float
            The accuracy of the model on the dataset given by the loader

    num_correct = 0
    num_samples = 0

    # We don't need to keep track of gradients here so we wrap it in torch.no_grad()
    with torch.no_grad():
        # Loop through the data
        for x, y in loader:

            # Move data to device
            x =
            y =

            # Get to correct shape
            x = x.reshape(x.shape[0], -1)

            # Forward pass
            scores = model(x)
            _, predictions = scores.max(1)

            # Check how many we got correct
            num_correct += (predictions == y).sum()

            # Keep track of number of samples
            num_samples += predictions.size(0)

    return num_correct/num_samples

# Check accuracy on training & test to see how good our model
print(f"Accuracy on training set: {check_accuracy(train_loader, model)*100:.2f}")
print(f"Accuracy on test set: {check_accuracy(test_loader, model)*100:.2f}")