U.S. patent application number 15/485112 was filed with the patent office on 2017-10-05 for custom class library generation method and apparatus.
The applicant listed for this patent is Intel Corporation. Invention is credited to Gopinatth SELVARAJE, Lei Luc SHI, Mingqiu SUN, Ligang WANG, Xin WANG.
Application Number | 20170286072 15/485112 |
Document ID | / |
Family ID | 55458252 |
Filed Date | 2017-10-05 |
United States Patent
Application |
20170286072 |
Kind Code |
A1 |
SHI; Lei Luc ; et
al. |
October 5, 2017 |
CUSTOM CLASS LIBRARY GENERATION METHOD AND APPARATUS
Abstract
Apparatuses, methods and storage media associated with
generating a custom class library are disclosed herein. In
embodiments, an apparatus may include an analyzer configured to
receive a workload for a device and a class library used by the
workload, analyze the workload and class library, identify one or
more workload full API call chains, and generate information about
the one or more workload full API call chains. Further, the
apparatus may include a generator to generate from the class
library, a custom class library for the workload that is smaller
than the class library, based at least in part on the one or more
workload full API call chains. Other embodiments may be disclosed
or claimed.
Inventors: |
SHI; Lei Luc; (Beijing,
CN) ; WANG; Xin; (Beijing, CN) ; SUN;
Mingqiu; (Beaverton, OR) ; WANG; Ligang;
(Beijing, CN) ; SELVARAJE; Gopinatth; (Portland,
OR) |
|
Applicant: |
Name |
City |
State |
Country |
Type |
Intel Corporation |
Santa Clara |
CA |
US |
|
|
Family ID: |
55458252 |
Appl. No.: |
15/485112 |
Filed: |
April 11, 2017 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
14778521 |
Sep 18, 2015 |
9632757 |
|
|
PCT/CN2014/086215 |
Sep 10, 2014 |
|
|
|
15485112 |
|
|
|
|
Current U.S.
Class: |
1/1 |
Current CPC
Class: |
G06F 8/427 20130101;
G06F 8/63 20130101; G06F 8/31 20130101; G06F 9/44521 20130101; G06F
8/36 20130101; G06F 8/315 20130101 |
International
Class: |
G06F 9/44 20060101
G06F009/44; G06F 9/445 20060101 G06F009/445 |
Claims
1. An apparatus for generating a custom class library for a device,
comprising: one or more processors; and an analyzer to be operated
by the one or more processors to receive a workload for the device
and a class library used by the workload, analyze the workload and
the class library, identify one or more workload full application
programming interface, API, call chains that include direct calls
from the workload to the class library, and subsequent calls within
the class library resulted from the direct calls from the workload
to the class library, and generate information about the one or
more workload full API call chains.
2. The apparatus of claim 1, wherein the analyzer is to parse the
class library, and based on a result of the parsing, generate
connectivity information that describes a calling relationship
between each class or API in the class library.
3. The apparatus of claim 2, wherein the analyzer is to further
generate, based on the result of the parsing, an API information
table that stores, for each API, a unique identifier of the API, a
prototype of the API having a return value and one or more
parameters, and the API's containing class identifier.
4. The apparatus of claim 2, wherein the analyzer is to further
generate, based on the result of the parsing, a method invoking
table that stores, for each API, one or more method identifiers
identifying one or more methods directly invoked by the API.
5. The apparatus of claim 2, wherein the analyzer is to further
generate, based on the result of the parsing, a field invoking
table that stores, for each API, one or more field identifiers
identifying one or more fields invoked by the API.
6. The apparatus of claim 1, wherein the analyzer is to parse the
workload, and based on a result of the parsing of the workload,
generate one or more records of API invocation of the workload or
the class library.
7. The apparatus of claim 6, wherein the analyzer is to identify
the one or more workload full API call chains, based at least in
part on the one or more records of API invocation of the workload
or the class library, and the connectivity information that
describes the calling relationship between each class or API in the
class library.
8. The apparatus of claim 1, further comprising a generator to be
operated by the one or more processors to generate from the class
library, a custom class library for the workload that is smaller
than the class library, based at least in part on the one or more
workload full API call chains.
9. The apparatus of claim 8, wherein the class library comprises a
Java.RTM. Virtual Machine, JVM, class library.
10. The apparatus of claim 8, wherein the workload comprises a
workload for an Internet of Things (IoT) device.
11. A method for generating a custom class library for a device,
comprising: receiving, by a computing device, a workload for the
device and a class library used by the workload; analyzing, by the
computing device, the workload and the class library to identify
one or more workload full application programming interface, API,
call chains that include direct calls from the workload to the
class library and subsequent calls within the class library
resulted from the direct calls from the workload to the class
library; and generating, by the computing device, information about
the one or more workload full API call chains.
12. The method of claim 11, wherein analyzing comprises parsing the
class library, and based on a result of the parsing, generating
connectivity information that describes a calling relationship
between each class or API in the class library.
13. The method of claim 12, wherein analyzing comprises generating,
based on the result of the parsing, an API information table that
stores for each API, a unique identifier of the API, a prototype of
the API having a return value and one or more parameters, and the
API's containing class identifier.
14. The method of claim 12, wherein analyzing comprises generating,
based on the result of the parsing, a method invoking table that
stores for each API, one or more method identifiers identifying one
or more methods directly invoked by the API.
15. The method of claim 12, wherein analyzing comprises generating,
based on the result of the parsing, a field invoking table that
stores for each API, one or more field identifiers identifying one
or more fields invoked by the API.
16. The method of claim 11, wherein analyzing comprises parsing the
workload, and based on a result of the parsing of the workload,
generating one or more records of API invocation of the workload or
the class library.
17. The method of claim 16, wherein analyzing comprises identifying
the one or more workload full API call chains, based at least in
part on the one or more records of API invocation of the workload
or the class library and the connectivity information that
describes the calling relationship between each class or API in the
class library.
18. The method of claim 11, further comprising: generating from the
class library, by the computing device, a custom class library for
the workload that is smaller than the class library, based at least
in part on the one or more workload full API call chains.
19. (canceled)
20. (canceled)
21. At least one storage medium comprising a plurality of
instructions to cause an apparatus, in response to execution of the
instructions by the apparatus, to: receive a worklaod for the
device and a class library used by the workload; analyze the
workload and the class library, identify one of more workload full
application programming interface, API, call chains that include
directs calls from the workload to the class library, and
subsequent calls within the class library resulted from the direct
calls from the workload to the class library; and generate
information about the one or more workload full API call
chains.
22. (canceled)
23. (canceled)
24. (canceled)
25. (canceled)
26. The computer-readable storage medium of claim 19, wherein to
analyze is to parse the class library, and based on a result of the
parsing, generate connectivity information that describes a calling
relationship between each class or API in the class library.
27. The computer-readable storage medium of claim 26, wherein to
analyze is to further generate, based on the result of the parsing,
an API information table that stores for each API, a unique
identifier of the API, a prototype of the API having a return value
and one or more parameters, and the API's containing class
identifier.
28. The computer-readable storage medium of claim 26, wherein to
analyze is to further generate, based on the result of the parsing,
a method invoking table that stores for each API, one or more
method identifiers identifying one or more methods directly invoked
by the API.
29. The computer-readable storage medium 26, wherein to analyze is
to further generate, based on the result of the parsing, a field
invoking table that stores for each API, one or more field
identifiers identifying one or more fields invoked by the API.
30. The computer-readable storage medium 19, wherein to analyze is
to parse the workload, and based on a result of the parsing of the
workload, generate one or more records of API invocation of the
workload or the class library.
31. The computer-readable storage medium of claim 19, wherein the
apparatus is further caused to generate from the class library, a
custom class library for the workload that is smaller than the
class library, based at least in part on the one or more workload
full API call chains.
Description
TECHNICAL FIELD
[0001] The present disclosure relates to the field of computing, in
particular, to apparatuses, methods and storage media associated
with generating a custom class library for a device.
BACKGROUND
[0002] The background description provided herein is for the
purpose of generally presenting the context of the disclosure.
Unless otherwise indicated herein, the materials described in this
section are not prior art to the claims in this application and are
not admitted to be prior art by inclusion in this section.
[0003] Internet of Things (IoT) is booming. Huge volumes of IoT
sensors, controllers and smart meters being deployed are typically
designed with very limited resources in terms of memory and flash
space for applications to run. For example, most edge devices have
less than 1 MB of total memory.
[0004] In particular, there is a strong demand to run Java.RTM.
applications on these devices for the cross-platform application
portability and the massive Java.RTM. developer base. However,
standard Java.RTM. Virtual Machine (JVM) class libraries are
normally too big to fit into the tiny IoT devices. For example, a
standard JVM runtime usually contains a large library, such as the
OpenJDK library of Java 7, which contains 4024 application
programming interfaces (APIs) and takes about 80 MB of storage.
[0005] A typical solution to address this problem is to create a
small version of Java.RTM. by reducing the functionality of the
Java.RTM. class library, such as Oracle's JavaCard and J2ME.
However, such an approach sacrifices functionalities and destroys
compatibility with desktop and server Java.RTM. applications.
BRIEF DESCRIPTION OF THE DRAWINGS
[0006] Embodiments will be readily understood by the following
detailed description in conjunction with the accompanying drawings.
To facilitate this description, like reference numerals designate
like structural elements. Embodiments are illustrated by way of
example, and not by way of limitation, in the figures of the
accompanying drawings.
[0007] FIG. 1 illustrates a component view of the present
disclosure for generating a custom class library for a device, in
accordance with various embodiments.
[0008] FIG. 2 illustrates an overview of a process for generating a
custom class library for a device, in accordance with various
embodiments.
[0009] FIG. 3 illustrates generation of library internal API call
chains, in accordance with various embodiments.
[0010] FIG. 4 illustrates generation of workload full API call
chains, in accordance with various embodiments.
[0011] FIG. 5 illustrates generation of the custom class library in
further details, in accordance with various embodiments.
[0012] FIG. 6 illustrates a component view of an example computer
system suitable for practicing the disclosure, in accordance with
various embodiments.
[0013] FIG. 7 illustrates an example storage medium with
instructions configured to enable a computing device to practice
the present disclosure, in accordance with various embodiments.
DETAILED DESCRIPTION
[0014] Apparatuses, methods and storage media associated with
generating a custom class library are disclosed herein. In
embodiments, an apparatus may include an analyzer configured to
receive a workload and a class library, analyze the workload and
class library, identify one or more workload full API call chains,
and generate information about the one or more workload full API
call chains. The one or more workload full API call chains may
include direct calls from the workload to the class library, and
subsequent calls within the class library resulted from the direct
calls from the workload to the class library. Further, the
apparatus may include a generator to generate, from the class
library, a custom class library for the workload that is smaller
than the class library, based at least in part on the one or more
workload full API call chains. An example of the class library may
be a JVM class library. An example of the workload may be a
workload for an IoT device.
[0015] In the following detailed description, reference is made to
the accompanying drawings, which form a part hereof, wherein like
numerals designate like parts throughout, and in which is shown, by
way of illustration, embodiments that may be practiced. It is to be
understood that other embodiments may be utilized and structural or
logical changes may be made without departing from the scope of the
present disclosure. Therefore, the following detailed description
is not to be taken in a limiting sense, and the scope of certain
embodiments is defined by the appended claims and their
equivalents.
[0016] Operations of various methods may be described as multiple
discrete actions or operations in turn, in a manner that is most
helpful in understanding the claimed subject matter. However, the
order of description should not be construed as to imply that these
operations are necessarily order dependent. In particular, these
operations may not be performed in the order of presentation.
Operations described may be performed in a different order than the
described embodiments. Various additional operations may be
performed and/or described operations may be omitted, split or
combined in additional embodiments.
[0017] For the purposes of the present disclosure, the phrase "A
and/or B" means (A), (B), or (A and B). For the purposes of the
present disclosure, the phrase "A, B, and/or C" means (A), (B),
(C), (A and B), (A and C), (B and C), or (A, B and C).
[0018] The description may use the phrases "in an embodiment," or
"in embodiments," which may each refer to one or more of the same
or different embodiments. Furthermore, the terms "comprising,"
"including," "having," and the like, as used with respect to
embodiments of the present disclosure, are synonymous.
[0019] As used hereinafter, including the claims, the term "module"
may refer to, be part of, or include an Application Specific
Integrated Circuit (ASIC), an electronic circuit, a processor
(shared, dedicated, or group) and/or memory (shared, dedicated, or
group) that execute one or more software or firmware programs, a
combinational logic circuit, and/or other suitable components that
provide the described functionality.
[0020] Referring now to FIG. 1, a component view of the present
disclosure for generating a custom class library for a device, in
accordance with various embodiments, is illustrated. As
illustrated, an arrangement 100 for generating a custom class
library for a device, e.g., a custom Java.RTM. class library for an
IoT device, may include analyzer 102 and generator 104. In
embodiments, analyzer 102 may be configured to receive workload 112
for a device, and class library 114 used by workload 112, as
inputs, and to analyze workload 112 and class library 114 to
identify one or more library internal API call chains 116 and one
or more workload full API call chains 118. Additionally, analyzer
102 may be configured to generate information about the one or more
library internal API call chains 116 and the one or more workload
full API call chains 118. The one or more workload full API call
chains 118 may include direct calls from workload 112 to class
library 114, and subsequent calls within class library 114 resulted
from the direct calls from workload 112 to class library 114.
Further, generator 104 may be configured to generate from class
library 114, custom class library 120 for workload 112 that is
smaller than the class library 114, based at least in part on the
one or more workload full API call chains 118. The smaller size may
be achieved through exclusion of the non-invoked classes and APIs
of the full class library. Resultantly, relatively compact custom
class libraries 120 may be generated for a wide variety of small
IoT devices with limited resources and that run only relatively
small workloads, while maintaining compatibility across platforms
for workload 112. Examples of IoT devices may include, but are not
limited to, wearable devices, industrial Internet devices, home
automation devices, and so forth.
[0021] Referring now to FIG. 2, an overview of a process for
generating a custom class library for a device, in accordance with
various embodiments, is shown. As illustrated, process 200 for
generating custom class library 120 for a device may include
operations performed at blocks 202-206. The operations of blocks
202 and 204 may be performed, e.g., by the earlier described
analyzer 102 of FIG. 1. The operations of block 206 may be
performed, e.g., by the earlier described generator 104 of FIG.
1.
[0022] Process 200 may start at block 202. At block 202, a class
library may be scanned and analyzed to identify library internal
API call chains and generate information about these library
internal API call chains. The operations will be further described
later on with reference to FIG. 3. From block 202, process 200 may
proceed to block 204.
[0023] At block 204, a workload may be scanned and analyzed to
identify workload full API call chains and generate information
about these workload full API call chains. Recall that the one or
more workload full API call chains may include direct calls from
the workload to the class library, and subsequent calls within the
class library resulted from the direct calls from the workload to
the class library. In embodiments, the workload may be similarly
scanned and analyzed on a Breadth First Search (BFS) basis. The
operations will be further described later on with reference to
FIG. 4. From block 204, process 200 may proceed to block 206.
[0024] At block 206, a custom class library that is smaller than
the class library may be generated from the class library, based at
least in part on the workload full API call chains. The operations
will be further described later on with reference to FIG. 5. From
block 206, process 200 may end.
[0025] Referring now to FIG. 3, generation of library internal API
call chains, in accordance with various embodiments, is shown. As
illustrated, in embodiments, class files 302 in a class library
(e.g., class library 114) may each include a class file layout 304
having super class name, inner class name, method pool, field pool,
interface name, and so forth. Class files 302 may be scanned and
analyzed for dependency to generate a topological connectivity
graph to represent the calling relationship between each class
and/or API in the class library. In embodiments, class files 302
may be scanned and analyzed on a Breadth First Search (BFS) basis.
All class library internal API invoking and invoked relationship
information obtained from the scanning and analysis may be stored
in a dependency database (DB) 306. In embodiments, the information
may be stored in at least four tables, API Info Table 308, Method
Invoking Table 310, Field Invoking Table 312 and Class Table 314.
In alternate embodiments, more or fewer tables, or other data
structures, may be used instead.
[0026] API info table 308 may store an API ID, the API's prototype
and the API's containing class ID. In embodiments, the API ID may
be a unique identifier assigned to each API (in the case of
Java.RTM., including each Java.RTM. field and each Java.RTM.
method) as part of the scanning analysis. The API prototype (return
value and parameters) may be obtained from class files 302.
Containing class ID may be obtained from Class Table 314 (after it
has been built) by searching the class name.
[0027] Method Invoking Table 310 may store information of method(s)
directly invoked by a given API. In the case of Java.RTM., one part
of the invoked method(s) may be obtained from the bytecode of
invoke_virtual and invoke_static. The operand of bytecode indicates
invoked API name and containing class. The other part of the
invoked method(s) may be obtained from the bytecode of
invoke_special and invoke_interface. The operand of the bytecode
indicates invoked API and the accurate super class or interface may
be determined by searching Class Table 304 (after it has been
built).
[0028] Field Invoking Table 312 may store information of field(s)
directly invoked by a given API. In the case of Java.RTM., the
invoked field name(s) may be obtained from the bytecode of
putfield, getfield, putstatic and getstatic. The operand of the
bytecode is invoked field names, and they may be converted into API
ID by searching API Info Table 308.
[0029] Class Table 314 may store information of each
class/interface and their inheritance relationship obtained during
scanning.
[0030] Referring now to FIG. 4, generation of workload full API
call chains, in accordance with various embodiments, is shown. As
illustrated, in embodiments, a class file 402 in a workload (e.g.,
workload 112) may include a class file layout 404 having
information similar to class file layout 304 earlier described.
Class files 402 may be scanned and analyzed to identify all the
direct calls from the workload to a class library. The subsequent
calls within the class library resulted from the direct calls from
the workload to the class library may be obtained from dependency
DB 406 having class library internal call chain information
(similar to earlier described dependency DB 306). Similar to the
scanning and analysis of class files 302, class files 402, together
with the subsequent calls within the class library may be likewise
scanned and analyzed on a Breadth First Search (BFS) basis. As a
result, final invoked API list 408 having the workload full API
call chains that include the resulting subsequent calls within the
library may be generated.
[0031] Referring now to FIG. 5, generation of the custom class
library in further details, in accordance with various embodiments,
is shown. As illustrated, operations 500 for generating the custom
class library may include operations performed in blocks 502-508.
The operations may be performed, e.g., by the earlier described
generator 104 of FIG. 1.
[0032] At block 502, an API may be retrieved, e.g., from the
earlier described API Table 308 in dependency DB 306.
[0033] At block 504, a determination may be made about the
containing class for the API, e.g., from the earlier described API
Table 308 in dependency DB 306.
[0034] At block 506, the retrieved API and its containing class may
be copied into the custom class library.
[0035] At block 508, a determination may be made on whether all
applicable APIs have been examined, that is all APIs involved as
indicated by the workload full API call chains. The determination
may be made, e.g., based on whether all APIs have been retrieved
from API Table 308 in dependency DB 306, and examined. If all
applicable APIs have been examined, the generation operations may
end. However, if not all applicable APIs have been examined,
operations 500 may continue back at block 502, as earlier
described.
[0036] Operations at blocks 502-508 may then be repeated.
Operations at blocks 502-508 may then be repeated as many times as
necessary, until all applicable APIs (e.g., all APIs within API
Table 308 in dependency DB 306) have been examined/processed.
[0037] Referring now to FIG. 6, wherein an example computer
suitable for use for the arrangement of FIG. 1, in accordance with
various embodiments, is illustrated. As shown, computer 600 may
include one or more processors or processor cores 602, and system
memory 604. In embodiments, multiples processor cores 602 may be
disposed on one die. For the purpose of this application, including
the claims, the terms "processor" and "processor cores" may be
considered synonymous, unless the context clearly requires
otherwise. Additionally, computer 600 may include mass storage
device(s) 606 (such as diskette, hard drive, compact disc read only
memory (CD-ROM) and so forth), input/output device(s) 608 (such as
display, keyboard, cursor control and so forth) and communication
interfaces 610 (such as network interface cards, modems and so
forth). In embodiments, a display unit may be touch screen
sensitive and includes a display screen, one or more processors,
storage medium, and communication elements, further it may be
removably docked or undocked from a base platform having the
keyboard. The elements may be coupled to each other via system bus
612, which may represent one or more buses. In the case of multiple
buses, they may be bridged by one or more bus bridges (not
shown).
[0038] Each of these elements may perform its conventional
functions known in the art. In particular, system memory 604 and
mass storage device(s) 606 may be employed to store a working copy
and a permanent copy of the programming instructions implementing
the operations described earlier, e.g., but not limited to,
operations associated with analyzer 102 and/or generator 104,
denoted as computational logic 622. The various elements may be
implemented by assembler instructions supported by processor(s) 602
or high-level languages, such as, for example, C, that can be
compiled into such instructions.
[0039] The permanent copy of the programming instructions may be
placed into permanent mass storage device(s) 606 in the factory, or
in the field, through, for example, a distribution medium (not
shown), such as a compact disc (CD), or through communication
interface 610 (from a distribution server (not shown)). That is,
one or more distribution media having an implementation of an agent
program may be employed to distribute the agent and program various
computing devices.
[0040] The number, capability and/or capacity of these elements
610-612 may vary, depending on the intended use of example computer
600, e.g., whether example computer 600 is a smartphone, tablet,
ultrabook, laptop or a server. The constitutions of these elements
610-612 are otherwise known, and accordingly will not be further
described.
[0041] FIG. 7 illustrates an example non-transitory
computer-readable storage medium having instructions configured to
practice all or selected ones of the operations associated with
analyzer 102 and/or generator 104, earlier described, in accordance
with various embodiments. As illustrated, non-transitory
computer-readable storage medium 702 may include a number of
programming instructions 704. Programming instructions 704 may be
configured to enable a device, e.g., computer 600, in response to
execution of the programming instructions, to perform, e.g.,
various operations associated with analyzer 102 and/or generator
104 of FIG. 1 or various operations of FIGS. 2-5 respectively. In
alternate embodiments, programming instructions 704 may be disposed
on multiple non-transitory computer-readable storage media 702
instead. In still other embodiments, programming instructions 704
may be encoded in transitory computer readable signals.
[0042] Referring back to FIG. 6, for one embodiment, at least one
of processors 602 may be packaged together with a computer-readable
storage medium having computational logic 622 (in lieu of storing
in system memory 604 and/or mass storage device 606) configured to
practice all or selected ones of the operations associated with
analyzer 102 and/or generator 104 of FIG. 1, or aspects of
operations of FIGS. 2-5. For one embodiment, at least one of
processors 602 may be packaged together with a computer-readable
storage medium having computational logic 622 to form a System in
Package (SiP). For one embodiment, at least one of processors 602
may be integrated on the same die with a computer-readable storage
medium having computational logic 622. For one embodiment, at least
one of processors 602 may be packaged together with a
computer-readable storage medium having computational logic 622 to
form a System on Chip (SoC). For at least one embodiment, the SoC
may be utilized in, e.g., but not limited to, a hybrid computing
tablet/laptop.
[0043] Accordingly, embodiments for generating custom class
libraries for a device have been described. Example embodiments may
include the following.
[0044] Example 1 may be an apparatus for generating a custom class
library for a device. The apparatus may include one or more
processors and an analyzer. The analyzer may be operated by the one
or more processors to receive a workload for the device and a class
library used by the workload, analyze the workload and the class
library, identify one or more workload full application programming
interface, API, call chains that include direct calls from the
workload to the class library, and subsequent calls within the
class library resulted from the direct calls from the workload to
the class library, and generate information about the one or more
workload full API call chains.
[0045] Example 2 may be example 1, wherein the analyzer may parse
the class library, and based on a result of the parsing, generate
connectivity information that describes a calling relationship
between each class or API in the class library.
[0046] Example 3 may be example 2, wherein the analyzer may further
generate, based on the result of the parsing, an API information
table that stores for each API, a unique identifier of the API, a
prototype of the API having a return value and one or more
parameters, and the API's containing class identifier.
[0047] Example 4 may be example 2, wherein the analyzer may further
generate, based on the result of the parsing, a method invoking
table that stores for each API, one or more method identifiers
identifying one or more methods directly invoked by the API.
[0048] Example 5 may be example 2, wherein the analyzer may further
generate, based on the result of the parsing, a field invoking
table that stores for each API, one or more field identifiers
identifying one or more fields invoked by the API.
[0049] Example 6 may be any one of examples 1-5, wherein the
analyzer may parse the workload, and based on a result of the
parsing of the workload, generate one or more records of API
invocation of the workload or the class library.
[0050] Example 7 may be example 6, wherein the analyzer may
identify the one or more workload full API call chains, based at
least in part on the one or more records of API invocation of the
workload or the class library, and the connectivity information
that describes a calling relationship between each class or API in
the class library.
[0051] Example 8 may be any one of examples 1-7, further comprising
a generator to be operated by the one or more processors to
generate, from the class library, a custom class library for the
workload that is smaller than the class library, based at least in
part on the one or more workload full API call chains.
[0052] Example 9 may be example 8, wherein the class library may
comprise a Java.RTM. Virtual Machine, JVM, class library.
[0053] Example 10 may be example 8, wherein the workload may
comprise a workload for an Internet of Things (IoT) device.
[0054] Example 11 may be a method for generating a custom class
library for a device. The method may comprise receiving, by a
computing device, a workload for the device and a class library
used by the workload; analyzing, by the computing device, the
workload and the class library to identify one or more workload
full application programming interface, API, call chains that
include direct calls from the workload to the class library, and
subsequent calls within the class library resulted from the direct
calls from the workload to the class library; and generating, by
the computing device, information about the one or more workload
full API call chains.
[0055] Example 12 may be example 11, wherein analyzing may comprise
parsing the class library, and based on a result of the parsing,
generating connectivity information that describes a calling
relationship between each class or API in the class library.
[0056] Example 13 may be example 12, wherein analyzing may further
comprise generating, based on the result of the parsing, an API
information table that stores for each API, a unique identifier of
the API, a prototype of the API having a return value and one or
more parameters, and the API's containing class identifier.
[0057] Example 14 may be example 12, wherein analyzing may further
comprise generating, based on the result of the parsing, a method
invoking table that stores for each API, one or more method
identifiers identifying one or more methods directly invoked by the
API.
[0058] Example 15 may be example 12, wherein analyzing may further
comprise generating, based on the result of the parsing, a field
invoking table that stores for each API, one or more field
identifiers identifying one or more fields invoked by the API.
[0059] Example 16 may be any one of examples 11-15, wherein
analyzing may comprise parsing the workload, and based on a result
of the parsing of the workload, generating one or more records of
API invocation of the workload or the class library.
[0060] Example 17 may be example 16, wherein analyzing may comprise
identifying the one or more workload full API call chains, based at
least in part on the one or more records of API invocation of the
workload or the class library, and the connectivity information
that describes a calling relationship between each class or API in
the class library.
[0061] Example 18 may be any one of examples 11-17, further
comprising generating from the class library, by the computing
device, a custom class library for the workload that is smaller
than the class library, based at least in part on the one or more
workload full API call chains.
[0062] Example 19 may be example 18, wherein the class library may
comprise a Java.RTM. Virtual Machine, JVM, class library.
[0063] Example 20 may be example 18, wherein the workload may
comprise a workload for an Internet of Things (IoT) device.
[0064] Example 21 may be an apparatus for generating a custom class
library for a device. The apparatus may comprise means for
receiving a workload for the device and a class library used by the
workload; means for analyzing the workload and the class library to
identify one or more workload full application programming
interface, API, call chains that include direct calls from the
workload to the class library, and subsequent calls within the
class library resulted from the direct calls from the workload to
the class library; and means for generating information about the
one or more workload full API call chains.
[0065] Example 22 may be example 21, wherein means for analyzing
may comprise means for parsing the class library, and based on a
result of the parsing, generating connectivity information that
describes a calling relationship between each class or API in the
class library.
[0066] Example 23 may be example 22, wherein means for analyzing
may further comprise means for generating, based on the result of
the parsing, an API information table that stores for each API, a
unique identifier of the API, a prototype of the API having a
return value and one or more parameters, and the API's containing
class identifier.
[0067] Example 24 may be example 22, wherein means for analyzing
may further comprise means for generating, based on the result of
the parsing, a method invoking table that stores for each API, one
or more method identifiers identifying one or more methods directly
invoked by the API.
[0068] Example 25 may be example 22, wherein means for analyzing
may further comprise means for generating, based on the result of
the parsing, a field invoking table that stores for each API, one
or more field identifiers identifying one or more fields invoked by
the API.
[0069] Example 26 may be any one of examples 21-25, wherein means
for analyzing may comprise means for parsing the workload, and
based on a result of the parsing of the workload, generating one or
more records of API invocation of the workload or the class
library.
[0070] Example 27 may be example 26, wherein means for analyzing
may comprise means for identifying the one or more workload full
API call chains, based at least in part on the one or more records
of API invocation of the workload or the class library, and the
connectivity information that describes a calling relationship
between each class or API in the class library.
[0071] Example 28 may be any one of examples 21-27, further
comprising means for generating from the class library a custom
class library for the workload that is smaller than the class
library, based at least in part on the one or more workload full
API call chains.
[0072] Example 29 may be example 28, wherein the class library may
comprise a Java.RTM. Virtual Machine, JVM, class library.
[0073] Example 30 may be example 28, wherein the workload may
comprise a workload for an Internet of Things (IoT) device.
[0074] Example 31 may be one or more non-transitory
computer-readable storage medium having instructions that, in
response to execution of the instructions by an apparatus, cause
the apparatus to: receive a workload for the device and a class
library used by the workload; analyze the workload and the class
library; identify one or more workload full application programming
interface, API, call chains that include direct calls from the
workload to the class library, and subsequent calls within the
class library resulted from the direct calls from the workload to
the class library; and generate information about the one or more
workload full API call chains.
[0075] Example 32 may be example 31, wherein to analyze may
comprise to parse the class library, and based on a result of the
parsing, generate connectivity information that describes a calling
relationship between each class or API in the class library.
[0076] Example 33 may be example claim 32, wherein to analyze may
comprise further to generate, based on the result of the parsing,
an API information table that stores for each API, a unique
identifier of the API, a prototype of the API having a return value
and one or more parameters, and the API's containing class
identifier.
[0077] Example 34 may be example 32, wherein to analyze may
comprise to further generate, based on the result of the parsing, a
method invoking table that stores for each API, one or more method
identifiers identifying one or more methods directly invoked by the
API.
[0078] Example 35 may be example 34, wherein to analyze may
comprise to further generate, based on the result of the parsing, a
field invoking table that stores for each API, one or more field
identifiers identifying one or more fields invoked by the API.
[0079] Example 36 may be any one of examples 31-35, wherein to
analyze may comprise to parse the workload, and based on a result
of the parsing of the workload, generate one or more records of API
invocation of the workload or the class library.
[0080] Example 37 may be example 36, wherein to analyze may further
comprise to identify the one or more workload full API call chains,
based at least in part on the one or more records of API invocation
of the workload or the class library, and the connectivity
information that describes a calling relationship between each
class or API in the class library.
[0081] Example 38 may be any one of examples 31-37, wherein the
apparatus may be further caused to generate from the class library,
a custom class library for the workload that is smaller than the
class library, based at least in part on the one or more workload
full API call chains.
[0082] Example 39 may be example 38, wherein the class library may
comprise a Java.RTM. Virtual Machine, JVM, class library.
[0083] Example 40 may be example 38, wherein the workload may
comprise a workload for an Internet of Things (IoT) device.
[0084] Although certain embodiments have been illustrated and
described herein for purposes of description, a wide variety of
alternate and/or equivalent embodiments or implementations
calculated to achieve the same purposes may be substituted for the
embodiments shown and described without departing from the scope of
the present disclosure. This application is intended to cover any
adaptations or variations of the embodiments discussed herein.
Therefore, it is manifestly intended that certain embodiments
described herein be limited only by the claims.
[0085] Where the disclosure recites "a" or "a first" element or the
equivalent thereof, such disclosure includes one or more such
elements, neither requiring nor excluding two or more such
elements. Further, ordinal indicators (e.g., first, second or
third) for identified elements are used to distinguish between the
elements, and do not indicate or imply a required or limited number
of such elements, nor do they indicate a particular position or
order of such elements unless otherwise specifically stated.
* * * * *