Kotlin Language Features Related to Null Handling

-
Any software engineer with a Java background would find the null handling features in the Kotlin language interesting. Let's summarize this topic with some examples. Nullable types: In Kotlin, types are non-nullable by default. If you want a variable to be able to hold a null value, you need to explicitly declare its type as nullable using the Type? syntax. For example, String? denotes a nullable string, while String represents a non-nullable string. Safe calls (?.): Kotlin introduces the safe call operator (?.) for handling nullable types. It allows you to safely invoke a method or access a property on a nullable object. If the object is null, the expression returns null instead of throwing a NullPointerException. Example: data class Person(val name: String, val age: Int, val address: String?) fun main() {     // Create a person with a nullable address     val person1 = Person("John Doe", 25, "123 Main Street")     val person2 = Person("Jane Doe", 30,
Post a Comment

SimpleScalar Simulator

-
I used to work with Java over the past years and now I have to deal with a simulator that was written in C. It's been a while since I wrote, read and built any C code so it may not be a very easy journey. Let me share how I try to understand the simulator step by step:

  • SimpleScalar is a suite of processor simulators and supporting tools. Using the SimpleScalar tools, users can build modeling applications that simulate real programs running on a range of modern processors and systems.
  • SimpleScalar architecture is a close derivative of the MIPS architecture.
  • The tool set takes binaries compiled for the SimpleScalar architecture and simulates their execution on one of several provided processor simulators.
  • SimpleScalar provides sets of precompiled binaries (including SPEC95), plus a modified version of GNU GCC (with associated utilities) that allows us to compile our own SimpleScalar test binaries from C code.
  • Different simulators perform differently depending on the detail level. 

The five distribution files in the directory are:

simplesim.tar.gz - contains the simulator sources, the instruction set definition macros, and test program source and binaries. This file is required for installation of the tool set.

simpleutils.tar.gz - contains the GNU binutils source, retargeted to the SimpleScalar architecture. These utilities are not required to run the simulators themselves, but is required to compile your own SimpleScalar benchmark binaries (e.g. test programs other than the ones we provide)

simpletools.tar.gz - contains the retargeted GNU compiler and library sources needed to build SimpleScalar benchmark binaries. This file is needed only to build benchmarks, not to compile or run the simulators.

simplebench.big.tar.gz - contains a set of the SPEC95 benchmark binaries, compiled to the SimpleScalar architecture running on a big-endian host.

Installing and running Simplescalar


Benchmarks written in C are compiled using the SimpleScalar version of GCC, which generates SimpleScalar assembly. The SimpleScalar assembler and loader, along with the necessary ported libraries, produce SimpleScalar executables that can then be fed directly into one of the provided simulators. (The simulators themselves are compiled with the host platform’s native compiler; any ANSI C compiler will do).
If you use the precompiled SPEC95 binaries or the precompiled test programs, all you have to install is the simulator source itself. If you wish to compile your own benchmarks, you will have to install and build the GCC tree and optionally (recommended) the GNU binutils.

 Endianness

The SimpleScalar architecture, like the MIPS architecture, supports both big-endian and little-endian executables. The tool set supports compilation for either of these targets; the names for the big-endian and little-endian architecture are ssbig-na-sstrix and sslittle-na-sstrix, respectively. You should use the target endian-ness that matches your host platform; the simulators may not work correctly if you force the compiler to provide crossendian support. To determine which endian your host uses, run the endian program located in the simplesim-2.0/ directory.

NOTE: Using make files:

http://www.cs.colby.edu/maxwell/courses/tutorials/maketutor/

Installing SimpleScalar under Windows:

https://www.codefull.org/2016/01/simplescalar-installation-under-windows/

http://www.ee.ryerson.ca/~courses/ee8207/simplescalar.doc

NOTE: Cygwin is a Unix-like environment and command-line interface for Microsoft Windows.

(Try with Virtual Box - Ubuntu)

https://www.virtualbox.org/manual/ch01.html#idm374

https://www.liberiangeek.net/2013/09/copy-paste-virtualbox-host-guest-machines/

https://github.com/sdenel/How-to-install-SimpleScalar-on-Ubuntu

http://www.cse.psu.edu/~mtk2/

Installing SimpleScalar to Ubuntu. (changing some source code is needed)

**
http://godblesstangkk.blogspot.com.tr/2013/01/install-simplescalar-30-on-ubuntu-1204.html

**
http://www.cse.iitd.ernet.in/~cs5070217/csl718/assignment1/ss_install_instructions.html

http://harryscode.blogspot.com.tr/2008/10/installing-simplescalar.html

Gem5 Tutorials:

https://www.youtube.com/watch?v=fD3hhNnfL6k

http://learning.gem5.org/index.html


After looking at many blog posts about simplescalar installation, I was able to compile a hello world C program for simplescalar (using special version of gcc), and then I was able to run sim-safe simulator for the hello world program. The output is:

sim: ** simulation statistics **
sim_num_insn                   7940 # total number of instructions executed
sim_num_refs                   4337 # total number of loads and stores executed
sim_elapsed_time                  1 # total simulation time in seconds
sim_inst_rate             7940.0000 # simulation speed (in insts/sec)
...

My host operating system is Window 8.1, I use Oracle VirtualBox and the Linux version is 4.2.0-27-generic i686

Comments

Post a Comment

Popular posts from this blog

Trie Data Structure and Finding Patterns in a Collection of Words

-
Image
 I faced a very hard problem recently about finding substrings based on a collection of patterns.  Example For  words = ["Apple", "Melon", "Orange", "Watermelon"]  and  parts = ["a", "mel", "lon", "el", "An"] , the output should be  findSubstrings(words, parts) = ["Apple", "Me[lon]", "Or[a]nge", "Water[mel]on"] . While  "Watermelon"  contains three substrings from the  parts  array,  "a" ,  "mel" , and  "lon" ,  "mel"  is the longest substring that appears first in the string. Note: Number of words and number of parts can be huge! A brute force method or careless usage of Java String methods would make it impossible to handle a large number of words and parts (patterns). Solution Approach Whenever we want to search patterns inside a string, we should think about the Trie data structure:  https://en.wikipedia.
Read more

swapLexOrder: Finding lexicographically largest string

-
The following coding question is really amazing: Given a string  str  and array of  pairs  that indicates which indices in the string can be swapped, return the  lexicographically largest  string that results from doing the allowed swaps. You can swap indices any number of times. Example For  str = "abdc"  and  pairs = [[1, 4], [3, 4]] , the output should be swapLexOrder(str, pairs) = "dbca" . By swapping the given indices, you get the strings:  "cbda" ,  "cbad" ,  "dbac" ,  "dbca" . The lexicographically largest string in this list is  "dbca" . Input/Output [execution time limit] 3 seconds (java) [input] string str A string consisting only of lowercase English letters. Guaranteed constraints: 1 ≤ str.length ≤ 10 4 . [input] array.array.integer pairs An array containing pairs of indices that can be swapped in  str  (1-based). This means that for each  pairs[i] , you can swap elements in  str  that have the indices  p
Read more

Virtual Memory

-
The main memory can act as a “cache” for the secondary storage, usually implemented with magnetic disks. This technique is called virtual memory. There were two major motivations for virtual memory: to allow efficient and safe sharing of memory among multiple programs, and to remove the programming burdens of a small, limited amount of main memory. Lets consider a collection of programs running all at once on a computer. Of course, to allow multiple programs to share the same memory, we must be able to protect the programs from each other, ensuring that a program can only read and write the portions of main memory that have been assigned to it. Main memory need contain only the active portions of the many programs, just as a cache contains only the active portion of one program. Virtual memory allows us to efficiently share the processor as well as the main memory. We cannot know which programs will share the memory with other programs when we compile them. In fact, the programs s
Read more