Object and method exploration for embedded systems

Object and Method Exploration for Embedded Systems
Applications
Júlio C. B. Mattos Luigi Carro
Federal University of Rio Grande do Sul Federal University of Rio Grande do Sul
Informatics Institute Informatics Institute
Porto Alegre - RS - Brasil Porto Alegre - RS - Brasil
julius@inf.ufrgs.br carro@inf.ufrgs.br
ABSTRACT Embedded systems are heterogeneous systems that cover a broad
The growing complexity of embedded systems has claimed for range of algorithms implemented on hardware and software. In
more software solutions in order to reduce the time-to-market. the past, hardware configurations dominated the field while today
However, while this software decrease the development time of most of the applications are implemented in a mixed
the embedded system functionalities , it must at the same time configuration where software constitutes the main part [1,2].
help the handling of the embedded systems tight constraints, like Probably in the future even more products will have most of their
energy, power and memory availability. Object orientation is now characteristics developed in software. In many cases software is
a common technique to write maintainable code, but its preferred to a hardware solution because it is more flexible, easier
application to the embedded systems domain is withhold by the to update and can be reused. Hence, software is more and more
overhead in terms of memory, performance and code size. This becoming the major cost factor for embedded devices [3, 4].
paper introduces a methodology to explore object-oriented Over the years, embedded software coding has been traditionally
embedded software improving different levels in the software developed in assembly language, since there are stringent memory
design, while dealing with different embedded systems and performance limitations [5]. On the other hand, the best
requirements (power, memory area and performance). The software technologies use large amounts of memory, layers of
proposed approach transforms the original OO code into an abstraction, elaborate algorithms, and these approaches are not
optimized code allowing the automatic configuration of a solution directly applicable in embedded systems [5]. However, hardware
for a specific application. Experimental results with an MP3 capabilities have been improved, and the market demands more
player show a large design space exploration with different elaborate products, increasing software complexity. Thus, the use
solutions in terms of performance, energy and memory. of better software methodologies is clearly required, for example
object orientation. Nevertheless these abstract software techniques
Categories and Subject Descriptors require a high price in the embedded domain, and the problem of
C.3 [Special-Purpose and Application-Based Systems]: Real- embedded software development for this market still exists.
time and embedded systems; D.1.5 [Programming Techniques]: One of the main stream software methodologies is the object-
Object-oriented Programming. oriented paradigm. In the last decades the object-oriented
mechanism has become the dominant programming paradigm.
General Terms Object-oriented programming scales very well, from the most
Languages, Measurement, Performance. trivial problems to complex ones. In spite of object orientation
advantages, the acceptance in the embedded world has been slow,
since embedded software designers are reluctant to employ these
Keywords techniques due the memory and performance overhead [6, 7, 8].
Embedded Software, Object-Oriented, Design Space Exploration.
Moreover, over the past few years embedded developers have
embraced Java, because this technology can provide high
1. INTRODUCTION portability and code reuse for their applications [9, 10, 11]. In
Nowadays, the embedded system market does not stop growing,
addition, Java has features such as efficient code size and small
and new products with different applications are available. These
memory footprint, that stand out against other programming
systems are everywhere, for example, mobile telephones, cars,
languages, which makes Java an attractive choice as the
videogames and so on. In embedded applications, requirements
specification and implementation language of embedded systems.
like performance, reduced power consumption and program size,
However, developers should be free to use any object oriented
among others, must be considered. Moreover, the embedded
coding style and the whole package of advantages that this
systems complexity is increasing in a considerable way.
language usually provides. In any case, one must also deal with
Permission to make digital or hard copies of all or part of this work for the limited resources of an embedded system.
personal or classroom use is granted without fee provided that copies are
As mentioned, the existing software methodologies are not
not made or distributed for profit or commercial advantage and that
copies bear this notice and the full citation on the first page. To copy
adequate for embedded software development, because embedded
otherwise, or republish, to post on servers or to redistribute to lists, software development should address different constraints from
requires prior specific permission and/or a fee. desktop software. In this way, this paper introduces a
SBCCI’07, September 3–6, 2007, Rio de Janeiro, Brazil. methodology to explore object-oriented embedded software
Copyright 2007 ACM 978-1-59593-816-9/07/0009…$5.00. improving different tasks in the system design. Our approach is

318

divided into two main parts where the embedded software objects in immortal memory can be created and accessed without
exploration methodology can be improved. GC delay, but there is no mechanism for freeing those objects
during the application execution. This approach is similar to our
The first part, called method exploration level, aims to improve
strategy of transforming dynamic objects into static ones.
the methods implementation (the algorithms that implement these
However, it is necessary to use the RTSJ (during application
methods). This exploration phase introduces a mechanism for the
code) and modify the virtual machine to adopt this technique.
automatic selection of software and hardware IP components for
embedded applications, which is based on a software IP library There are other approaches to improve memory behavior of Java
and a design space exploration tool. programs, for example [21]. However, these techniques improve
the data locality during the execution time. Another paper [22]
The second part, called object exploration level, aims to explore
proposes a region analysis and transformation for Java programs.
the object organization to improve the dynamic memory
But, in this approach, the code must be modified and it is
management through the use of a design space exploration tool to
necessary to extend the virtual machine to support region
allow an automatic selection of the best object organization. This
annotations and to provide region run-time support.
approach is also compliant with classical OO techniques and
physical embedded systems requirements. The overall goal is to Shaham [23] presents a similar strategy. But, our proposed
provide high level object orientation support, while at the same approach starts from a more radical point of view. Instead of
time support optimized memory, power and performance for trying just to improve the code written by the programmer, we try
embedded systems. to automatically transform as many dynamic objects into static
ones, in the goal to reduce execution time, while maintaining
Moreover, the tools here presented (one based on method and
memory costs as low as possible. Thus, it provides a large design
another based on object exploration) are mutually orthogonal, that
space exploration for a given application.
is, their execution is independent. The designer can first use the
method exploration tool and after the object exploration tool or
vice-versa. Since the optimizations performed by each tool are 3. DESIGN SPACE EXPLORATION OF OO
orthogonal, this makes the complexity of the exploration simple. EMBEDDED SOFTWARE
This paper is organized as follows. Section 2 discusses related This section shows the two main parts that our methodology is
work in the field of embedded software optimization. Section 3 divided. The first part, called method exploration level, aims to
presents our approach to design space exploration of object improve the method implementation (the algorithms that
oriented embedded software. Section 4 presents some results implement these methods). The second part, called object
using a case study. Finally, section 6 draws conclusions and exploration level, aims to explore the object organization to
introduces future work. improve the dynamic memory management.

3.1 Method exploration level
2. RELATED WORK This section shows the method exploration approach. The main
Our method approach is similar to [12], but instead of aiming at a idea is to explore different algorithm solutions (method
partitioning between software and hardware, it concentrates on implementations) for a certain application according to the
algorithmic variations of software routines that are commonly embedded system requirements. This approach consists in the use
found in a wide range of embedded applications. This way, it of a software library, a set of different processor cores (but with
provides design space exploration for given platforms. the same instruction set), and a design space exploration tool to
allow an automatic software and hardware IP selection. The
The optimizations (in method and object level) that we proposed
software IP library contains alternative algorithmic
are different from most of studies. Most approaches on embedded
implementations for routines commonly found in embedded
software optimization are based on traditional compilation
applications, whose implementations are previously characterized
optimization. There are lots of works that deal with compilation
regarding performance, power, and memory requirements for
optimizations concerning performance, memory, energy [13, 14,
each processor core.
15]. Our approach differs from these, because our approach
intends to improve the code before the compiler optimization. We In our approach, the designer receives the application
believe that design decisions taken at higher abstraction levels can specification and after coding it in Java language using the
lead to substantially superior improvements. software IP library, he/she submits the application to the design
space exploration tool. This methodology is compliant with the
There are several works that agree with our statement that object-
component-based development, where a component is a self-
orientation and Java produce huge overhead [6, 7, 16]. However,
contained part or subsystem that can be used as a building block
these papers only measure this overhead. The main problem with
in a larger system. Using component-based development style, the
Java is the overhead produced by memory management. In this
reuse become easier and increase the software productivity.
way, there are lots of works that proposed software and hardware
solutions to reduce the overhead as well to make the CG more The software IP library contains different algorithmic versions of
predicable [17, 18, 19]. These strategies are very different from the same function thus supporting design space exploration.
ours. Our object exploration level works before the execution – Considering a certain core (HW IP) and for each algorithmic
when the memory management and garbage collector act. implementation of the library functions, it measures the
performance, the memory usage, and energy and power
The Real-Time Specification for Java (RTSJ) [20] introduces the
dissipation. This way, the characterization of the software library
concept of immortal memory to improve real-time aspects. The
is performed according to physical related aspects that can be

319

changed at an algorithmic abstraction level. On hardware level, In the exploration tool, before the search begins, the user may
this approach uses different implementations of the same determine the application requirements (weights for power, delay
Instruction Set Architecture providing range solutions on and memory optimization). The tool automatically explores the
performance, power and memory area. design space and finds the optimal or near optimal mapping for
that configuration. In the final step (code generation phase), the
Thus, this methodology allows the automatic selection of software
tool links the algorithm calls to their implementation according to
and hardware IPs to better match the application requirements.
the results obtained in exploration phase.
Moreover, if the application constraints might change, for
example with tighter energy demands or smaller memory Problem Complexity
footprint, a different set of SW and/or HW IPs might be selected.
The design space to be explored can be large. The number of
Using this methodology, the space design exploration has several solutions is function of the number of the processor cores (HP
options to provide a final solution using a different combination IPs) and the number of the routines (SW IPs) that are available.
of SW IPs and HW IPs. Using only a single core and different
The equation of the problem complexity can be obtained as
algorithmic versions of the same function, the designer has a good
follows. There is a program with m different methods that use the
set of alternatives. However, when multiple cores are used, the
IP library. Each method can be implemented by r different
range of solutions is hugely increased.
algorithmic solutions. The IP library was characterized into p
Figure 1 shows the design flow of this embedded SW exploration. processor cores. Thus, each method can be implemented by one
After coding the application using de IP library, the designer of the r*p options. Finally, if there are m different methods in the
submits the application to design exploration tool. The design program, the exploration tool should evaluate several options
exploration tool maps the routines of an embedded program to an given by equation:
implementation using instances of the software IP library, so as to
fulfill given system requirements. The user program is modeled as m
(r * p)
a graph, where the nodes represent the routines, while the arcs
determine the program sequence. The weight of the arcs where r is the number of different implementations of the same
represents the number of times a certain routine is instantiated. In routine, p is the number of the available processor cores and m is
our approach, different threads are modeled as parallel structures the number of different method that uses the IP library in the
and can be mapped to different processor cores. program.

Application Requirements Application
3.2 Object exploration level
This section shows the software exploration approach to improve
XML Java Application
the dynamic memory management. The main idea in this level is
to explore the organization of the objects of the application
Software Library according the requirements. Our approach is composed by a
Graph Extractor
design space exploration tool that allows an automatic selection of
the best object organization. When a programmer uses an object-
Graph Extractor Phase

XML Package
oriented design paradigm, the application objects can be statically
or dynamically allocated. When the programmer uses static
Graph
Thread1
1
Thread2
1
allocation the memory footprint is known at compilation time.
sin 2 5 5 4 Hence, in this approach, normally, the memory size is big, but
XML
10 15 15 76 imdct

100 sin
there is a lower execution overhead while dealing with the
5

dynamic allocation (produced by the memory manager). On the
other hand, when the programmer uses a dynamic allocation,
Exploration
there is an overhead in terms of performance, but the memory size
Tool decreases because the garbage collector removes the unreachable
Exploration Phase

objects.

Method Configuration
The related work and our experimental results [24] shown that,
for some OO applications, the largest part of the execution time is
XML
taken just by memory management. However, if the designer
allocates memory in a static fashion, the price to be paid is a
much larger memory than it is actually needed, with obvious
Code Generation Phase

Code Tool problems in cost, area and static and dynamic power dissipation.
This tool is divided into three main parts: analysis phase,
transformation phase and design space exploration phase. Figure
Final Application
2 shows the design flow. The methodology starts with the original
application analysis and stores the results on a database.
Class Files
Afterwards, the tool transforms, in an automatic way, each
allocation instruction that allocated objects dynamically to a static
Figure 1. Method Exploration Level Design Flow. way memory reservation. Afterwards, the tool analyzes each
modified application and stores the results on the database. This

320

task is done to the whole allocation instructions. The final step the database results, the exploration tool searches for the best
does the design space exploration. Based on application object organization that fulfills the requirements. The output is a
requirements provided by the designer, the tool tries to search the list of allocation instructions that should be transformed into static
best object organization (objects allocated dynamically or allocation. This list is used as input of the transformation step to
statically). make the final application.
In analysis phase, the tool extracts the results from one Our problem is very similar to the 0-1 Knapsack Problem [25].
application. The results are based on: object results: these results The problem consists in searching the best combination of
show the number of allocated objects for some instance execution, performance and memory of a set of objects transformations. We
and the number of allocation instructions, object time life, number implemented our algorithm using dynamic programming [26].
of accesses per object and object size, etc; memory results: these Application Application Requirements
results show the total dynamic memory allocated during the
application execution, the maximum memory utilization and a Class Files XML

memory usage histogram; performance results: these show the
performance results in terms of executed instructions and the
overhead caused by GC. Analysis Tool
Transformation Exploration
The analysis phase provides the object, memory and performance Tool Tool

results and stores these results in a database that will be used by

Transformation Phase
Application

the exploration phase. This task analysis is done to the whole

Exploration Phase
Modified Application Final Configuration

allocation instructions, one by one, after the transformation step. Instrumented Class Files

Class Files XML

This phase aims to transform the object that has been previously
Java VM
dynamically allocated into statically allocated objects. The idea
assumes that objects allocated dynamically produce more
overhead in terms of performance, because of the memory Results

Analysis Phase
management, while objects allocated statically produce less
overhead in terms of performance, but cause memory overhead, DAT File Code Tool
since there must be extra memory space while the application is

Code Generation Phase
Results Storage
executing. The tool transforms the dynamically allocated objects Results
Processing
into static ones by manipulating the Java bytecodes. XML
Final Application

In the exploration phase, the tool does the design space Class Files

exploration. Based on the application requirement provided by the
designer, the tool tries to search for the best object organization
(objects allocated dynamically or statically). The main goal of
Figure 2. Object Exploration Level Design Flow.
this phase is to search, based on the original application, which
objects will be changed into static ones. One of the inputs of the
tool is a set of results (the database generated during the analysis 4. EXPERIMENTAL RESULTS
phase) that shows: the allocation instruction number This section presents the results of our approach to explore
(identification number), the performance improvement object-oriented embedded software. The case study application,
(instructions) and the memory overhead (bytes). The other input target platform and results are presented in the following.
is the application requirements.
4.1 Application
Problem Complexity MPEG-Audio is an international standard for digital high quality
This problem has a large design space to be explored. The number sound compression. Generally speaking, the standard takes a
of combinations that the tool should search is function of the digital audio file and reduces its size, while maintaining the
number of allocation instructions that can be changed to static quality of the recording. Our application code is based on a
allocation. Thus, the exploration tool should evaluate several description freely available on the Internet [27]. All the MP3 code
options given by equation: was written in Java but obeying certain constraints of our
architecture. An example constraint is the use of integer arrays
2n instead of floating-point arrays because there is no such unit
available in the processor.
where n is the number of allocation instructions that can be
changed. This equation can be obtained as follows. For example, 4.2 Target Platform
in OO program, there are n allocation instructions. All of these We use a platform composed by different core implementations of
instructions can be converted to static ones. Each allocation the same ISA. The platform is based on different implementations
instruction can be dynamic or static, thus there are 2n possible of a Java processor, called FemtoJava [28, 29]. This processor
combinations. Each combination is composed by a set of implements an execution engine for Java in hardware through a
allocation instructions that allocates in dynamic or static way. stack machine compatible with Java Virtual Machine (JVM)
specification. In this work, we use the multicycle version and the
The solution to the proposed problem needs a heuristic algorithm pipeline version.
because of its complexity. Based on application requirements and

321

4.3 Results The figure 4 shows the results in terms of power versus the
This section shows the results of our approach. First, we increase of memory usage. As one can see, the different
summarize the results concerning method exploration level and processors dissipate different amounts of power (about 23-24mW
object exploration level on a MP3 application. in the pipeline processor and about 6-7mW in the multicycle
version). However, solutions based in the same processor
The method exploration level is based on software IP library and implementation present similar results in terms of dissipated
a set of cores (Java processors) that uses a tool for automatic power.
design space exploration and SW and HW IP selection. The
complete explanation of the library and its characterization was 25
presented in [30]. This software IP library contains different
algorithmic versions of the same function, like sine, table search, 20
square root, IMDCT, thus supporting design space exploration.

Power (mW)
Considering a certain core (HW IP) and for each algorithmic 15
implementation of the library functions, it measures performance,
memory usage (for data and instruction memories), and energy 10

and power dissipation.
5
In the object exploration level, the tool tries to transform, in an
automatic way, as many dynamic objects to static ones, in the 0
goal to reduce execution time, while maintaining memory costs as 22.500 32.500 42.500 52.500 62.500 72.500

low as possible. This idea is based on fact that a small part of the Memory (bytes)
code creates most part of the objects. For example, during the
MP3 execution 46,068 objects were created by only 101 Figure 4. MP3 Power vs. Memory Design Space.
allocation instructions, and hence some allocation instructions
created more than one object.
Finally, figure 5 shows the results in terms of energy. Based on
Figures 3, 4 and 5 show the design space exploration of the MP3 these solutions the exploration tool tries to find the best method
application that can be explored by the tools. There is a large implementation and the best object organization for certain
design space exploration. The number of solutions is defined by application and certain application requirements. For example, the
the number of method that can explored by the tool and the square solution presented in the three figures (pointed by an
number of allocation instructions that can be transformed. The arrow) represents a good solution in terms of performance. But it
plots in the figures show only a small part of possible solutions. has an overhead in terms of power.
The figures show different points: the black points represent
solutions running in the pipeline version of the processor. On the
7
other hand, the gray points represent the solutions running in the
6,5
multicycle one.
6
5,5
Energy (J)

470.000.000 5
420.000.000 4,5
Performance (cycles)

370.000.000 4
3,5
320.000.000
3
270.000.000
2,5
220.000.000 2
22.500 32.500 42.500 52.500 62.500 72.500
170.000.000
Memory (bytes)
120.000.000

70.000.000
22.500 32.500 42.500 52.500 62.500 72.500
Figure 5. MP3 Energy vs. Memory Design Space.
Memory (bytes)

Figure 3. MP3 Performance vs. Memory Design Space. 5. CONCLUSIONS AND FUTURE WORK
This paper introduces a methodology to explore object-oriented
embedded software, improving different tasks in the system
In the figure 3, the performance versus the increase of memory design. This design space exploration is divided into different
usage caused by the transformation of the dynamic objects to phases: the method exploration level and the object exploration
static ones is presented. The figure shows the corner cases (the level.
circle and the square). The black circle is the solution with worst
performance and minimum memory overhead and the black Experimental results have confirmed the hypothesis that there is a
square is the application with best performance and maximum large space to be explored based on decisions taken at higher
memory overhead. The black solutions present better results in levels of abstraction, much before compiler intervention.
terms of performance because uses the pipeline processor. Selecting the right algorithm, right architecture or right object
organization might give orders of magnitude of gain in terms of

322

physical characteristics like memory usage, performance, and Minimization. In: IEEE Transactions on Very Large Scale
power dissipation. Moreover, not only is this approach very Integration (VLSI) Systems, vol. 2, n. 4, Dec. 1994.
simple, but it can also lead to substantial gains. [15] Panda, P. R.; et al. Data and memory optimization
As a future work, we plan to evaluate the whole methodology techniques for embedded systems. ACM Trans. Des. Autom.
with more applications. Electron. Syst. 6, 2 (Apr. 2001), 149-206.
[16] El-Kharashi, M. W.; Elguibaly, F.; Li, K. F. A quantitative
6. REFERENCES study for Java microprocessor architectural requirements.
[1] Balarin, Felice; et al. Synthesis of Software Programs for Part II: High-level language support," Microprocessors and
Embedded Control Applications. IEEE Transactions on CAD Microsystems, vol. 24, no. 5, pp. 237-250, Sept. 1, 2000.
of Integrated Circuits and Systems, New York, June 1999. [17] Jones, Richard; Lins, Rafael D. Garbage Collection:
[2] Shandle, Jack; Martin, Grant. Making Embedded Software algorithms for automatic dynamic memory management.
reusable for SoCs. March, 01 2002. Chichester: John Wiley, 1996.
http://www.eetimes.com/news/design/features/showArticle.j [18] Lin, C.; Chen, T. Dynamic memory management for real-
html?articleID=16504598. time embedded Java chips. In Proceedings of Seventh
[3] Graaf, B., Lormans, M., Toetenel, H. Embedded Software International Conference on Real-Time Computing Systems
Engineering: The State of the Practice. IEEE Software, and Applications, 2000.
Nov./Dec. 2003, 61-69. [19] Ritzau, Tobias. Hard Real-Time Reference Counting without
[4] Embedded Systems Roadmap 2002. External Fragmentation In Proc. of the JOSES Workshop
http://www.stw.nl/progress/ESroadmap/index.html. Genoa, Italy, 2001.
[5] Lee, Edward. What’s Ahead for Embedded Software ?. IEEE [20] Bollella, G.; et al. The Real-TimeSpecification for
Computer, New York, p.18-26, Sept. 2000. Java.Addison-Wesley, June 2000.
[6] Detlefs, David L.; Dosser, Al; Zorn, Ben. Memory Allocation [21] Kistler, T.; Franz, M. Continuous program optimization: A
Costs in Large C and C++ Programs. Software Practice and case study. ACM Trans. Program. Lang. Syst. 25, 4 (Jul.
Experience, 24(6):527--542, June 1994. 2003), 500-548.
[7] Chatzigeorgiou, A.; Stephanides, G. Evaluating Performance [22] Cherem, S.; Rugina, R. Region analysis and transformation
and Power of Object-Oriented vs. Procedural Programming for Java programs. In Proceedings of the 4th international
in Embedded Processors. In Proceedings of 7th Ada-Europe Symposium on Memory Management, October, 2004. ISMM
International Conference on Reliable Software Technologies. '04. ACM Press, New York, NY, 85-96.
LNCS 2361. Springer-Verlag, 2002. 65-75. [23] Shaham, R.; Kolodner, E.; Sagiv, M. Heap profiling for
[8] Bhakthavatsalam, Sumithra; Edwards, Stephen H. Applying space-efficient Java. In Proceedings SIGPLAN Conf. on
object-oriented techniques in embedded software design. Prog. Lang. Design and Impl., ACM Press, 2001. 104-113.
CPES 2002 Power Electronics Seminar and NSF/Industry [24] Mattos, Júlio C. B.et al. Making Object Oriented Efficient
Annual Review, April, 2002. for Embedded System Applications.. In 18th Brazilian
[9] Lawton, G. Moving Java into Mobile Phones, IEEE Computer, Symp. Integrated Circuit Design (SBCCI 2005), Sep. 2005.
vol. 35, n. 6, 2002, 17-20. New York: ACM Press, 2005. p.104-109.
[10] Strom, Oyvind; Svarstad, Kjetil; Aas, Einar J. On the [25] Martello, Silvano; Toth, Paolo. Knapsack Problems:
Utilization of Java Technology in Embedded Systems, Algorithms and Computer Implementations. Chichester:
Design Automation for Embedded Systems, vol. 8, n. 1, John Wiley & Sons, 1990.
March 2003, 87-106. [26] Horowitz, Ellis; Sahni; Sartaj. Fundamentals of Computer
[11] Lanfear, Christopher; Ballaco, Sthepen. The Embedded Algorithms. Computer Science Press, 1978.
Software Strategic Market Intelligence: Java in Embedded [27] MP3, http://www.mp3-tech.org/, 2006.
Systems. July, 2003. http://www.vdc-corp.com/embedded/
[28] Ito, S. A.; Carro, L.; Jacobi, R. Making Java Work for
/white/03/03esdtvol4.pdf.
Microcontroller Applications, IEEE Design & Test, vol. 18,
[12] Reyneri, L.M.; et al. A Hardware/Software Co-design Flow no. 5, Sep-Oct, pp. 100-110.
and IP Library Based on Simulink. DAC’01 - Design
[29] Beck, A.C.S., Carro, L. “Low Power Java Processor for
Automation Conference, Proceedings, ACM, 2001.
Embedded Applications”. In: IFIP 12th International
[13] Dutt, N., et al. New Directions in Compiler Technology for Conference on Very Large Scale Integration, Germany,
Embedded Systems. In: Asia-Pacific Design Automation December, 2003.
Conference, Jan. 2001. Proceedings, IEEE Computer Society
[30] Mattos, Júlio C. B.et al. Design Space Exploration with
Press (2001).
Automatic Generation of IP-Based Embedded Software. In:
[14] Tiwari, V.; Malik, S.; Wolfe, A. Power Analysis of IFIP Conference on Distributed and Parallel Embedded
Embedded Software: a First Step Towards Software Power Systems, Boston: Kluwer Publishers, 2004. p.237-246.

323

Object and method exploration for embedded systems

More Related Content

What's hot (15)

Viewers also liked (6)

Similar to Object and method exploration for embedded systems (20)

More from Mr. Chanuwan (11)

Recently uploaded (20)

Object and method exploration for embedded systems