Abstract
Embedded processors are increasingly deployed in applicationsrequiring high performance with good real-timecharacteristics whilst being low power. Parallelism hasto be extracted in order to improve the performance atan architectural level. Extracting instruction level parallelismrequires extensive speculation which adds complexityand increases power consumption. Alternatively, parallelismcan be provided at the thread level. Many embeddedapplications can be written in a threaded manner inJava which can be directly translated to use hardware-levelmultithreaded operations. This paper presents an architecturalstudy of JMA, a high-performance multithreadedarchitecture which supports Java-multithreading and realtimescheduling whilst remaining low-power
.1. Introduction
In processor design, functional requirements and performancegoals are crucial factors. The functional requirementsare inspired by the processor market. The trendsfrom the market indicate that personal hand-held deviceshave an interesting potential to grow. These devices requireadvanced functional features like complex multimedia animation,images/audio encoding, cryptography and speechrecognition/synthesis. Many of these complex applicationsare naturally written in a threaded manner (e.g. decodingeach block of encoded animation or calculating each HMMnode during speech recognition).Today's high-end processors execute many instructionsper cycle, in order to work effectively, speculative executionor branch prediction are required. Such techniques adda great deal of complexity, increase the power consumption,and make real-time performance dif_cult to predict.Also of great concern is memory latency, since there is agrowing gap between processor cycle and memory accesstimes at approximately 50% per year [1]. Memory latencyshould be hidden by increasing the parallelism in the systemsuch that a pending load instruction does not stall the whole processor. However, memory latency tolerance is dif_cultwithin a single thread because of limited single-thread instructionlevel parallelism. Thus, the system that supportsthread level parallelism seems to be the best alternative toprovide latency tolerance and offer predictable performancegains.For this study, we chose the Java concurrency modelbecause it is increasingly used in embedded applications,and supports light weight threads through its Thread objectclass. We used the MIPS instruction set as a basis for ourstudy, adding just four instructions (see section 3.4).A brief background about Java-multithreading is presentedin section 2. Section 3 illustrates the hardware architecture.Experimental results are presented in section 4followed by the conclusion in section
2. Java Multithreading
1. Synchronisation:
Synchronisation prevents interferencebetween threads. Resources are guarded by havinglocks on them. Only one thread is handed a key toaccess its protected resources while the others have towait until it _nishes. Each thread can hold many keyssimultaniously.
2. Interthread Communication:
Threads communicateby sharing data via the same memory space usingthe synchronisation primitive.
3. Scheduling:
Scheduling determines the execution orderof multiple threads using their priorities. A threadcan voluntarily pass its privilege to waiting threads byusing yield(), or via the time-slicing mechanism.
4. Daemon Thread:
A daemon thread is an endlessloop waiting to provide important services to the otherthreads (e.g. a low-priority garbage collector, a highprioritytimer thread that wakes up in regular interval).
3. Multithreaded Architecture
To operate multiple threads concurrently, most architecturesemploy software support by translating each Javathreadoperation with a sequence of machine instructions.Unfortunately, these sequences consume a number of cyclesthat is often exacerbated by cache misses. Hence, an alternativesystem that can process multiple threads at the hardwarelevel using a minimised set of instructions has beeninvestigated. Our Java-Multithreading Architecture (JMA)requires a smaller number of instructions per Java-threadmethod and handles multithreading at the hardware level.


Download full report
http://citeseerx.ist.psu.edu/viewdoc/dow...1&type=pdf