Dojo (HowTo)







  Easter Eggs




  Martial Arts

Microprocessor Architecture for Java Computing

By:David K. Every
©Copyright 1999

Sun has a new Processor Architecture proposal called MAJC that could be very interesting -- in the future. Sun has a thing for acronyms, and MAJC (pronounced "magic") just rolls off the tongue like a cotton ball. MAJC stands for Microprocessor Architecture for Java Computing -- but that may be a misnomer and just another way for Sun to foist the Java name. The application of the architecture is broader than just for Java so it seems a little shortsighted to stuff the Java name in with a Microprocessor Architecture.

What is MAJC?

Sun's philosophy with MAJC is not to make another complex processor -- but instead to make a somewhat simpler one. So MAJC processors are simple (relatively) to implement, focusing on the I/O side of things (where there are currently bottlenecks) and making an architecture that is cheaper, lower power, easier to design and so on. This is a return to the core concepts of RISC: Reducing the Complexity in design and implementation, and then using that saved space (and time/money) to hopefully speed up or make the processor better in other significant ways.

In this case those "other ways" of making the processor better is not only lowering the power and cost, but in making multithreaded and multicore processors -- which is something that I've been advocating for quite a while in the PowerPC side of things (and long before). Sun's ideas are that Java is a threaded language, and so a threaded processor designed to work with it should be a cheaper way to make things go very fast overall (even if one thread isn't quite as fast by itself).

Java as a language is multithreaded from the start but that doesn't mean it handles multiple processors (or multiple cores) automatically -- it is just a long way along that path. So it shouldn't be too much work for Sun to rework Java to be fully multiprocessor ready (or handle multiple cores). Another advantage of Java is that there isn't a whole lot of legacy holding Java back (yet) from quick adaptations and progress -- so Java can go this way very easily. The MAJC processors are designed to exploit those things, and still not excluded from running other languages or systems. This is a much better attempt at adding some value and innovation to the market than Suns last Java processor attempts.

MAJC is a VLIW (Very Large Instruction Word) type of RISC design, and trying to be fully catch-phrase compliant. They are superscalar (allow multiple instruction to be executed at the same time). They support SIMD (like MMX or AltiVec). Sun put in a whole lot of registers (literally hundreds) to try to increase speed (and put some of the leftover space to good use). In an interesting move Sun made all the registers "universal", they are either Floating Point or Integer (or vectors?) -- this issue alone has many interesting possibilities which could either result in much better register usage (and slight performance improvements), or possibly worse chip-space utilization and performance (specialization of registers allows some reductions in certain design areas) -- we'll have to wait and see how things work out in the real world.

The chip seems to forgo 8 bit processing and works more often with 16, 32 or 64 bit data. This makes some sense because Java (and other systems) universal characters are longer using ASCII bytes (8 bits) for characters as much, and opting to Unicode words (16 bits) instead -- so it is getting near the time where programmers will use bytes (8 bits) a lot less frequently. But this break with the past and other tradeoffs (like VLIW) may have some hidden costs down the road. The most common is something called code creep and data creep -- which is where things are less memory efficient and take more memory with these processor than others. That problem is not only in storage (heck memory is getting cheap), but the problem is that moving more memory around means more I/O bandwidth, less efficient use of cache, and so on. And since processors are really more memory and I/O bound today than anything else (and that problem is getting worse, not better), this is a bigger issue than it sounds.

Sun seems to have taken note of this potential "flaw", and so has improved the way it works with I/O (memory) to have a crossbar switch to handle multiple connections to multiple types of devices at once. This is a sort of attempt to make one bus to behave like multiple busses (one for each core and each I/O port / support chip). Again, this alone is another innovation -- but something that other companies are doing on their own as well.

The MAJC Processor Architecture tries to do other things to speed up most Java (and higher level Object Oriented programs). It can deal with things like handling virtual functions, exceptions, rapid context switching, garbage collection and so on. These are things that modern OO-Languages do a lot, and are something that most current processor designs aren't really designed for. Other processors can do these things, but they are designed to run assembly language (machine code) really well -- and then remap higher level languages (like C++ or Java) around that -- so they just aren't quite as efficient. MAJC tries to make it easier to skip that intermediate step and help higher level languages more directly. Not a bad plan since more and more coding is being done at a higher and higher level, and that trend will continue.

One of the most innovate ideas to be reborn in MAJC architecture is to make an architecture that runs sort of as a pseudo interpreter of a language (like Java) and not compile things directly to the processor (as much). If Sun can sell this, then it means that they can change the processor implementation far more from version to version -- and get more adaptation, specialization and progressive innovation in the future.

The reason this idea is "reborn" and not unique to MAJC is that there have been many attempts at this in the past. UCSD had their interpreters around the late 70s (and some processors), and I believe others made Forth, Smalltalk, and tried for other "higher level" language processors as well. They failed at the time mostly because computers weren't fast enough back then and they didn't have enough chip (die) space to do it well -- and the extra layer of abstraction (that slows down performance) just killed them. Now days it might be time where we can trade off some speed for a lot more design rewards (like scalability and adaptability). So this could be a long term win -- if it can survive the short term performance penalties.


Each MAJC processor is probably fairly competitive with its single-thread performance (especially running higher level things like Java) -- but I doubt that MAJC will be nearly as fast for a single optimized system threads (written in C or Assembler) for the PowerPC, x86 or IA64 (Merced). The hope is that MAJC will make up for that by running multiple threads at once. If it can run multiple threads faster than other processors and MAJC can have multiple cores, and MAJC simpler and cheaper to design, upgrade and implement, then MAJC can build momentum and be a success. So there is potential in this design philosophy -- but we have to wait to see if the potential will be realized.

Think of this whole thing like moving. You can move from one place to another using one small truck, that goes really quickly (60 MPH) but have to make many trips (say 10). Or you can get a much bigger truck (or many trucks) that travel more slowly (say 30 MPH) but make fewer trips (say 1 or 2). Depending on the balances (how many trucks), you can come out way ahead by using slower trucks, or slower multicore processors. The design advantages of the MAJC chip are the same concepts that gave RISC and advantage over CISC, and allowed more rapid (and cost effective) implementations. Which is basically why almost every single processor architecture being furthered today is either RISC or borrows as many concepts from it as it can.

The size advantage of the MAJC core (processor) means that it will be easier to make lower power devices as well. In fact, the core is likely small enough that you should be able to integrate other parts of your system (computer hardware) on the same chip as the processor core -- eventually merging almost the entire computer onto a single chip. This means handheld devices, controllers, and attempts to take over the low end of the market.

This is a similar tack that Motorola has been taking with the 68000 and PowerPC, and IBM has been doing with the PowerPC. The idea being to empower embedded controllers that can be made simpler -- and people can customize chips to contain many functions that a designer might need for some handheld or embedded device -- thus lowering the overall cost and power (and possibly increasing the overall performance). Even some older x86 designs are being used in this way.

MAJC is innovative but timing is everything

There is no doubt that the MAJC architecture is innovative in many ways -- but it isn't as innovative as Sun is selling it as. Remember marketing is partly about hype (and taking credit) -- and Sun is taking credit for integrating many things that have existed elsewhere long before. Multiple cores, multithreaded processors, simplifying the design, making a higher level processor, and so on, have all existed before. To hear Sun sell it, they just invented everything. Yet the truth is that they are still the first ones to use many of these concepts in a long time, or to integrate all these things and push in these direction commercially (and in the low end of the market) -- so there is real innovation.

In fact, this processor is far more innovative in concept and direction than IA64 (Merced) -- and more innovative than say AltiVec or the latest generations of PowerPCs (AltiVec is just a brilliant implementation of older ideas, whereas MMX and SSE are just mediocre to poor implementations of older ideas). But innovation isn't always good. Innovation means change -- and change means cost. Innovation means people have to do a paradigm shift -- and too many close-minded people pop the clutch (and and technologies stall) when trying to make that shift. So there are a lot of questions about this dramatic of a change in concept, and how quick the industry can "get it" and adapt. In the past it has taken many years, many generations, and many tries to get it right. Remember, this chip will pretty much take a whole new way of thinking about software. It works best with Java design concepts -- but Java isn't a whole Operating System yet (and not even close), it is just a foundation for building one. Java is penetrating deep as a platform independent way to write code, especially in the corporate environment (as in Database Interface Language) and for some Internet delivery -- and it will continue to do so -- but it still has a long way to go to replace commercial software (or most software that people actually use directly). Platform independence is nice and Java adds a lot of value -- but what will a dedicated Java processor do to help that?

So the real question with MAJC remains -- Does the world really need another processor architecture?

I expect the MAJC implementations are at least a year away from market -- and then there needs to be support chips and infrastructure built. We are looking at a 2 - 3 year time frame to build momentum, and there just isn't a whole lot of commercial quality software for Java yet (for general purpose). So the MAJC processor may stand a chance in embedded and vertical (handheld, Set-top-box, etc.) type markets -- but it isn't going to mainstream for quite some time.

In the mean time, the PowerPC is a simple enough design that you can do multiple cores pretty easily and it is not much work to add some other instruction set changes to minimize any advantages that the MAJC processor might have. The PowerPC has a lot more momentum and a lot more software -- and is still like to be faster running traditional code, and will probably soon be faster at Java and future stuff (especially if PowerPC camp goes with the multiple core path).

On the really high end, IBM's GigaProcessor (the PowerPC or Power4 architecture that runs at over 1 GHz) has dual threads designed in -- and is a lot closer to reality than anyone else's multicore processors (at this time).

Even the x86 has a small faction that is into trying to simplify the x86 core (or use the simplest x86 designs they can), then used the saved space for other things like media processors, or SOC (System on a chip). Companies like IDT or Rise realize that they can get like 80% of the performance in like 50% (or less) of the space (transistors) of something complex like the current Pentium III or K7 cores. Soon, there will be enough transistors on the average processor to do multiple cores even in the x86 camp. It would make sense for a company like AMD (or IDT or Rise, or one of the many others) to borrow one of their older (simpler) x86 cores, and duplicate it on a mask to make a multicore implementation to compete with IA64 or other server versions of chips.

All this means that there multiple threaded processors (or multiple cores) are inevitable -- the question is just about when. Are we going to see multiple core (or multithreaded) processors start to take over in 1 year, 2 years, 5 years or more? Sun is just trying to follow that trend first (and lead), and trying to hype it up now (early). This is good because even though it is vapor (for now) the threat of the MAJC processor will likely intimidate other companies (like Motorola or IBM) into mainstreaming multicore processor sooner than they would have otherwise.


Sun is the only company out there that is consistently more arrogant than the old Apple (and often with less reasons to be). They don't play well with others and have NIH (Not Invented Here) syndrome -- but they really market hard (well?). It is just that they market things way before they are ready. So the problem with Sun is that they have the marketing equivalent of premature ejaculation. They build up hype -- but it also means that what they sell isn't quite mature enough, and so it flounders before it has a chance (partly due to unrealistic expectations caused by their own marketing). And for all the hype that Sun causes, they don't really exploit (or deliver) as much as they should. Suns marketing creates FUD (Fear Uncertainty and Doubt) which prevents companies from making big investments elsewhere (out of fear of what Suns delivery might do) -- which is pretty much a bad thing for the industry. But the fear also causes other companies to respond and do things to adapt -- like add Java support "just in case", or maybe start investigating multi-cores and higher level processors again -- which is a good thing. So Sun gets the attention -- but the follow-through takes a lot longer than it should -- and in fact, Sun isn't doing that well with actually succeeding at their own standards (though they are pushing the market forward).

Suns Java is a perfect example of all this. Sun had a good syntax (oak) that borrowed a lot of good ideas from many other places. But Sun took credit for it all, and didn't work well with others (team up) on many parts. There were many weaknesses that they could have strengthened by working with others but Sun just sort of snubbed others and acted like "we can do it ALL ourselves". Other parts of Java were just vapor, and are taking years to get worked out because of Suns arrogance -- and Sun should have had these things completed before they started selling Java as a solution in those areas. Embedded Java is an example -- and this processor may start to serious deliver in the next 3 years what has been promised in the last 3. Sun started by selling Java as being everything that it would someday be able to do -- and not based on the truth as to what it could do. Many people had false expectations and have a bad taste left in their mouth. Despite all the negatives, the hype did work in Suns favor, and Java is building momentum and is going to be an industry force -- maybe because of Sun, or maybe in spite of Sun.

MAJC seems to be just another example of those fundamental issues with Sun. They wants to push Java into the embedded space -- and they don't have the tools (processor, systems, software, etc.) to do it. Rather than working with others they sort of try to do it all on their own -- they are like a little wannabe Microsoft or Intel (if Microsoft or Intel owned the other). MAJC is an attempt to give us one of those tools (the processors) -- but I'd put its long term chances for success at about 50/50. I think its greatest success will be to scare other companies into exploring the same paths that Sun is (multiple cores, higher level function support in processors, etc.) -- and implementing them better, sooner and in systems that have more general purpose appeal.

Of course 50/50 still means Sun could suddenly build massive amounts of momentum behind its new processor and architecture. There isn't a lot known about the specifics of the processor and how far along it is -- we'll learn more in the next few months. For now, I'm betting that Sun is doing their usual "hype the vapor" technique -- and are not ready to announce a completed processor and OS (and development tools) to go with it. So far the features and design philosophy look good (and well thought out), and if they are ready to walk the walk (now that they've talked the talk) they could get some interest and momentum. We'll find out the truth soon. Personally, I am rooting for Sun and hope they shake up the industry -- but I just hope they do it with more substance and less hype than in the past.

More Info:

Created: 08/22/99
Updated: 11/09/02

Top of page

Top of Section