Updates will follow this week.

kor

kor

Drawing: BlazeRouter-M-ControlFlow(rev A)

Our tests will essentially be a face-off between BlazeRouter-M (w/Resource Reservation) vs. BlazeRouter-S (w/o Resource Reservation) and determine various metrics that will favor one over the other depending on the level of QoS required. This is the meat of my thesis.

Stay Tuned.

kor

The following is an outline or a promissory note of sorts, that details what I hope to accomplish for TheKlog in 2012. Hopefully, in due time, we’ll have regular visitors who find the information on here relevant to the work they do and can become contributors through commentary and/or posts.

Windows Embedded Compact 7:

• I have a wealth of information on Windows CE development and that includes a TON of notes on how to implement features that are common to Win32 developers alike. Obviously, there’s nothing out of the ordinary here, but what I want to do is give you, the reader, some of my own knowledge on what I’ve acquired over the course of seven years working with Windows CE directly in a format that’s easy to read and follow. Now, I realize that Windows CE has been phased out, BUT, if you’re still an Embedded Developer, then this might matter :

          Windows Embedded Compact 7 Links:

• http://www.microsoft.com/windowsembedded/en-us/campaigns/compact7/default.aspx?WT.mc_id=van_c7
• http://www.microsoft.com/windowsembedded/en-us/evaluate/windows-embedded-compact-7.aspx
• http://msdn.microsoft.com/en-us/library/gg154234.aspx

iPhone Development:

Over the course of six months, I’ve gained a lot of appreciation for the Objective-C language and I’m on the verge of completing my first application that will be submitted to the App Store under the auspices of Korwing (more on this later). Like my Windows CE notes from above, I want to provide concrete examples of the features I’ve worked with on my personal project. Hopefully these can give you some insight on the work you’re doing.

Android Development:

Towards the middle of the year, I’ll have a series of web videos that get into Java development with a heavy emphasis on Object Oriented programming. These videos are intended to reinforce and expand not only my limited knowledge of the Java language, but also yours as you consider working with the Android Framework. Some people have made it appoint to become developers without fully appreciating what the language has to offer. The problem with limited knowledge is that your programs are not as efficient as they should be, especially for mobile systems that have limited memory and are powered off a battery. True, the framework handles a lot of the nitty gritty details, but you’re still responsible for writing logical code that remains secure by design. Also, just because you can get a program out to the app store doesn’t necessarily make it an instant seller. Top selling apps are from those developers/companies who have taken the time to fully plan out their applications and design with care in mind. It pays to be thorough in your attempts to program, and I try to cover as many facets when doing so.

Git:

Along with any projects, you should become familiar with proper documentation and source code management. I’ve become a major advocate of SCM tools, especially Git. I’ll try to post some of my notes to help you get started.

Computer Architecture:

This is an engineering endeavor and my passion to teach will hopefully be exemplified as a worthy attempt to give current students in Computer Engineering a detailed yet ongoing discussion on the following topics:

• Computer Architecture – Introduction to CPU design. I’ll cover all the basics including terminology, performance, instruction design, arithmetic unit design, processors, pipelining, data and control paths, hazards, memory hierarchy, cache, virtual memory, cache coherence, disk storage, multicore and parallel processing.
• VHDL – The main project will involve designing an RTL based 32-bit RISC CPU. We’ll define a proper Instruction Set and work on the assembler that’ll become the basis of our tiny compiler for a simple programming language that we’ll define later using EBNF and programming it in the C language.
• Compiler Design - I’ll show you how to create a simple yet effective parser and syntax analyzer for our yet to be defined programming language. I’ll introduce you to Extended Backus-Naur Form (EBNF) to help define the tokens and lexemes for our language.
• C for Samurais – To be able to implement the compiler, you must become fluent with the C language. To become comfortable as a serious programmer who’s designing his/her own language, you need to have some idea of hardware. At this phase in our study, you will have already become accustom to the specific hardware we’re targeting: our 32-bit RISC CPU. This knowledge will only fortify your abilities in programming across many types of CPU’s. Therefore, this shouldn’t concern you once you get to this stage. However, what should concern you is how to manipulate data structures like linked lists and binary search trees to help you build your parser and analyzer, yet do it with performance in mind. Therefore, I need to familiarize you with Algorithm Design and how its execution is dependent on time with some important examples.

All of the material discussed will be covered sequentially. Most of my own research in the subject will be transcribed as notes to help teach you overtime. This is not a one month process. We’re talking a multi-year venture that will definitely take time to complete, so hang in there. I’m working on this.

kor

1. Download The Perforce Visual Client (P4V) here –> http://www.perforce.com/downloads/complete_list
2. Run the install and customize it so that all you’re really installing is the Visual Merge Tool (see figure).
3. Once the installation has completed, p4merge will be located under \Program Files\Perforce. No links are necessary as Windows will add p4merge to the global path.
4. Start Git Bash from either your repository or from the Git program folder.
5. At the prompt type in the following:

The first line sets the global path for all repositories to use the p4merge tool.

The second line assigns the necessary settings for the p4merge.exe tool. Here we want the  $BASE code as our reference to compare both the $LOCAL copy that you just edited/committed and are trying to push to the remote server where the $REMOTE copy resides. The $MERGED file is the final composition of your resolved conflicts that p4merge will display in it’s GUI.

In a subsequent post, I’ll go over the p4merge tool in detail. For now, this should get you up and running. Any problems? Leave me a comment.

kor

Well, since it’s the end of the year, I thought it’d be nice to get others involved who have a similar inclination in everything programming (C based that is) and want to contribute to an unofficial open source project. The hope is to find a small group of developers to help build the foundation of the web server.  It’s nothing fancy, right now, and I’m sure those who are pessimistic about the intention of such a project, would quickly point out that several other leading enterprise software on the market already fulfill the specification outlined here http://koru.github.com/Livepad/  and would easily quash any futile attempt to build something far less mature and primitive in design. However, taking that argument into consideration, one must also believe that there never exists just “one” of anything. There never was one brand of car, or one brand of cereal. Multiple flavors exists to satisfy varying niches, and that’s where Livepad comes in. I want to create a web server that satisfies the demands placed by Social Networking sites. Ambitious? VERY, but if it weren’t then what’s the point in doing it right?

So the work is more involved than just writing some code and kicking back to watch this whole process come to fruition. It involves proper research of current trends in social networking, understanding the needs of developers who might stick with default server deployments that host their application and never really consider alternatives. It’s also imperative to hear what I.T. thinks, because after all, they’re the ones who have to fan the flames, right?

Consideration for code optimization of the core is tantamount to increasing overall throughput. Therefore to prove that Livepad meets or exceeds it’s requirements, proper benchmarking in the following fields should be processed and compared with current market solutions:

• Resource Utilization (i.e. Processor Time/Memory Footprint)
• Power Consumption (a function of Resource Utilization on the node)
• Throughput and Latency under non-uniform traffic patterns

Kor

-kor

Going back to XP for my legacy software that will not run on dreaded Windows Siete

• BlazeRouter has now been broken up into three different routers: The first router is the original and will now be referred to as BlazeRouter-L, where L stands for Large. Go here for details –> https://github.com/koru/BlazeRouter
• The other two routers are called: BlazeRouter-M (https://github.com/koru/BlazeRouter_M) and BlazeRouter S (https://github.com/koru/BlazeRouter_S)
• As of today, all testing and development has been active on the BlazeRouter-M repo.
• Testing will be done in two main phases. The first phase is the Functionality Phase, where we test the router directly using a simple test bench that verifies the internal operation of all the features provided in the BlazeRouter.  The second phase involves the design of mesh based/torus based Network on Chip (NoC) with the BlazeRouter-M design. The maximum number of nodes that the BlazeRouter-M design can handle is 16, therefore, we can realize a 4×4 mesh in simulation. It’s expected that we also do a post-synthesis simulation on the design, however any expectation of the BlazeRouter-M in a NoC mesh based topology loaded on to a Virtex-4 FPGA is out of the question, as we have to incorporate a serializer for each channel on the router to prevent the mapping phase of design implementation on chip from failing.
• My notes will eventually be online regarding phase 1 testing. For now, stay tuned to TheKlog, as I will describe some more details about the BlazeRouter project.

Kor

Note: These are the control packets from a higher source (in our case, a Test Bench). The arbiter collects the packets and hands them off to the Reservation Table and Scheduler for storage. Eventually (hopefully by the end of today), the scheduler will read off the Time ID (TID) that denotes when the packet arrives and must leave the router by. The TID is compared to a running counter, which is incremented after a certain number of cycles (right now, we’re saying 1 ms).