Forem: Oku-Jo

Basic CPU Modeled in Python3

Oku-Jo — Wed, 24 Jan 2024 22:17:25 +0000

After completing the CodeCademy computer architecture course we have been tasked with using python to simulate the basic functions of a CPU.

My finished project can be found here:
https://github.com/Oku-Jo/cpu-modeled-in-python3/tree/main

This project is relatively open ended, and CodeCademy has provided some basic mips32 instructions and a few lines of data to test our constructs with. I ended up using significantly more than what we were provided to test our models with, and am glad I had done so.

I went into this knowing that I was going to struggle, so the goal I set for myself was to create a basic cpu that could handle a variety of randomly generated mips32 instructions (which adhere to the standard rules of mips32 instruction formatting) as well as an array of randomly generated data in addition to the provided instructions and data. I chose to do this so that I could be sure the model I was building was actually working, not just working with the provided data. I figured if I could build a simulated cpu that functions with externally-sourced instructions and data it would mean that I had gained a firm understanding of the material, both python3 and basic cpu architecture. The goal, after all, is to learn and to gain confidence that I have a good handle on what I've learned.

I have finished the cpu and it is currently handling instructions well, but my model was getting stuck in a loop with the full list of randomly generated instructions. I thought the source of my problem was somewhere in the structure of my model and spent far too long combing through and reorganizing everything only to realize that it might be the instructions causing the looping.
I have since gone through the instructions (which turned out to be the problem) and significantly curated them to create a cohesive set of instructions that handle branching and jumping very well. This allowed me to reuse many of the arithmetic instructions and to create a more interesting mips program.

The second aspect of this project that I wanted to spend a bit of extra time on was the structuring of the memory, the cache, and the cpu register. I wanted to make the transferring of data between register<->cache<->memory as reliable as possible before trying to do anything fancy with cache associativity, flagging cache blocks as dirty to increase efficiency/reduce frequency of memory writes, and anything more complex than a first-in-first-out cache replacement policy. My goal for the register<->cache<->memory is a functioning cpu register that works 1:1 with the many mips32 instructions (eventually all, but for now I am trying to keep it simple), a reliable fully associative cache with a FIFO policy (that can be updated in a future re-work), and a main memory structure that is quick to access using indices as addresses.

I built a Register class that I ended up taking apart and incorporating into the CPU class as it was getting very long winded to write out the decode_and_execute method, plus it was becoming more and more convoluted and less readable for someone to just jump into with no prior understanding of how I have structured this simulated CPU. Overall I think this was the right choice.

Shortcomings that I am aware of:
-None of the register/cache/memory have limits on bits per address/location. This can be updated in the future, but for now I have done what I set out to accomplish.
-None of this system uses binary or hex. In the future I can update this alongside adding limits to bits per location as well as how to handle results from the ALU being larger than bits-per-location allows, ie splitting and storing data as bytes vs half words vs words. This also includes updating how the Store Word mips32 instruction would handle the offset (+4/+8/+16 instead of +1 as it is currently).
-Don't have all mips32 instructions built in, but enough to handle arithmetic, jumping, and branching

Simple Movie Rec by Genre

Oku-Jo — Thu, 19 Oct 2023 15:23:10 +0000

Thanks for taking the time to read this. This is my first self-directed attempt at recommendation software. I am on the Codecademy CS track, and the assignment was to create any form of recommendation software I could come up with, and to include a form of autocomplete that would take minimal user input to suggest options they may have been considering.

I know this could use a little sprucing up, and I think when I have time I may come back and add the larger MovieLens dataset and incorporate the MovieLens ratings dataset to help further refine the user search. Currently this program is using the small MovieLens dataset for academic purposes.

Thanks again for your time!

https://github.com/Oku-Jo/Movie-Recommendations-by-Genre

Come join me in being judgy about my first project! Welcome to Simpletarot!

Oku-Jo — Thu, 30 Mar 2023 20:59:16 +0000

It means a lot that you would take the time to check out my little python project!

I am in the beginning stages of my coding competency, and I have been tasked with creating a python-based terminal game. I wanted to keep it simple to make sure I could complete the task, but also leave it open enough that I could iterate on it and introduce more user options and more complex code.

For my project I have created a simple tarot reader. This tarot reader contains two tarot decks, each comprised of only the major arcana cards to keep things manageable. The user is given the option to choose between a deck that does consider card orientation and one that doesn't. After choosing the type of deck, the user is then asked to choose either a single card draw (think magic 8-ball), or a three card spread, representing past, present, and future, as well as supplemental information to aid in interpretation.

I scraped a couple different tarot sites to gather the data, did a bit of manual cleaning-up of the data in google tables, and exported each deck to a csv file, both of which are included in the repository. In the script itself I turned the csv files into dictionaries in order to more easily present the data when a card (key) was drawn. To ensure no duplicates might be drawn, I wrote this program to create the deck dictionaries upon initialization, and then modify the dictionaries to remove key/value sets as cards were 'drawn.' This allowed me to keep things incredibly simple and functional, as my goal is to have a fully working product (and a learning experience).

Please feel free to share this, it is pure flattery that anyone might enjoy my work. Please also feel free to offer more elegant solutions as notes, but keep in mind that I am new to this. I may not yet be able to wrap my head around the more esoteric structures.

https://github.com/Oku-Jo/simpletarot

Also don't judge my readme too harshly. I intend to make it into an actual readme.
Special thanks to Nova for helping/teaching me the basics of data scraping!