Silicon Investor (SI) -- The First Internet Community

STOCKTALK

We've detected that you're using an ad content blocking browser plug-in or feature. Ads provide a critical source of revenue to the continued operation of Silicon Investor. We ask that you disable ad blocking while on Silicon Investor in the best interests of our community. If you are not using an ad blocker but are still receiving this message, make sure your browser's tracking protection is set to the 'standard' level.

Microcap & Penny Stocks : Patriot Scientific - PTSC -- Ignore unavailable to you. Want to Upgrade?

To: Delite who wrote (4092)	12/29/1997 9:04:00 PM
From: Jon Tara	Respond to of 8581

Here is one URL that is referenced by the PTSC web site, and a quote from that URL: techweb.com "One of the first Java-like CPUs is the PSC1000 from Patriot Scientific Corp. (San Diego). The Java VM maps so closely onto its architecture that 38 percent of the Java VM bytecodes translate directly into the same or fewer bytes of opcodes on the PSC1000." Hmmm, which is it, 79% or 38%? Looks like somebody's finger slipped, way over to the other side of the keyboard! If you read the PTSC site, you will find numerous references that support that notion that the PSC1000 is NOT a Java native processor. If it is, and if PTSC claims that it is, why would they themselves cite an article that refers to the PSC1000 as no more than "Java-like"? Here's another one, for good measure. This article is also referenced by the PTSC web site: techweb.com Efficient JIT compilation for a stack-based processor is a comparably trivial matter. It consists, during the byte-code verification process, of mapping Java byte-codes to processor opcodes and resolving compiled addresses. For the IADD instruction, the PSC1000 executes just one byte-sized opcode. It executes the same or fewer bytes of opcodes than the equivalent Java byte-codes for 38 percent of the Java VM instructions. Eleven percent require one additional opcode byte. Forty percent require two additional opcode bytes, or are complex operations that require a subroutine call, as they would on most embedded processors. The remaining 10 percent require six or fewer additional opcode bytes." Doesn't sound like a Java-native processor to me. A Java-native processor wouldn't need a JIT compiler (even an efficient one), and would require exactly one byte of instructions for every one byte of JVM bytecode.