Kreijstal

Overview

BSPrak is a custom setup for using QEMU through the GNU Guix package manager. This repository contains scripts and configurations to manage a custom QEMU build along with other essential tools.

Enter the Development Environment: Use guix shell to enter a shell with all necessary dependencies:

guix shell -m manifest.scm

Kreijstal

/*
 * Bitwise rotate a 32-bit number to the left.
 */
function ROTL(num, cnt)
{
  return (num << cnt) | (num >>> (32 - cnt));
}

/*
 * These functions implement the basic operation for each round of the

Kreijstal

VERILATOR = verilator
IVERILOG = iverilog
VVP = vvp

# Detect operating system
ifeq ($(OS),Windows_NT)
    DETECTED_OS := Windows
else
    DETECTED_OS := $(shell uname -s)
endif

Kreijstal

/* Copyright 2018 ETH Zurich and University of Bologna.
 * Copyright and related rights are licensed under the Solderpad Hardware
 * License, Version 0.51 (the “License”); you may not use this file except in
 * compliance with the License.  You may obtain a copy of the License at
 * http://solderpad.org/licenses/SHL-0.51. Unless required by applicable law
 * or agreed to in writing, software, hardware and materials distributed under
 * this License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *

Kreijstal

Introduction to Part III

A type system is, roughly, a mechanism for classifying the expressions of a language. Type systems for programming languages, sequential and concurrent, are useful for several reasons, most notably:

(1) to detect programming errors statically (2) to extract information that is useful for reasoning about the behaviour of programs (3) to improve the efficiency of code generated by a compiler (4) to make programs easier to understand.

Types are an important part of the theory and of the pragmatics of the $\pi$-calculus, and they are one of the most important differences between $\pi$-calculus and CCS-like languages. Many of the type systems that have been studied for the $\pi$-calculus were suggested by well-known type systems for sequential languages, especially $\lambda$-calculi. In addition, however, type systems specific to processes have been proposed, for instance for preventing certain forms of interference among processes or certain forms of deadlock.

Kreijstal

function Result(tag, value) {
  this.tag = tag;
  this.value = value;
}


Result.ok = function(value) {
  return new Result("ok", value);
};

Kreijstal

(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
(function (global){(function (){
'use strict';

var possibleNames = require('possible-typed-array-names');

var g = typeof globalThis === 'undefined' ? global : globalThis;

/** @type {import('.')} */
module.exports = function availableTypedArrays() {

Kreijstal

import typing as tp
import operator

# Defining the basic parser structure
ParserP = tp.Callable[[str], tp.Tuple[tp.Any, str]]

# Defining the ParserError for exception handling
class ParserError(Exception):
    def __init__(self, msg, content):
        super().__init__(f"{msg}: {content}")

Kreijstal

import subprocess
import tempfile
import os
import sys

def test_link(function_signature, flags):
    function_name = function_signature.split('(')[0].split()[-1].strip()
    with tempfile.NamedTemporaryFile(delete=False, suffix='.c', mode='w') as temp_file:
        test_code = f'''
#include <stdio.h>

Kreijstal

q:
```
The motion of a robot with a single prismatic joint can be modeled as: mq̈ + bq̇ + kq = f,

which depends on mass m = 2, stiffness k = 4, and friction b = 4.

We want to set the control force f = -kpx - kvẋ so that the controlled system is critically damped and has a closed-loop stiffness of k' = 8.

(Hint: a natural system is critically damped when b = 2√(mk.))