CN111061508B - Java card and performance optimization method thereof - Google Patents
Java card and performance optimization method thereof Download PDFInfo
- Publication number
- CN111061508B CN111061508B CN201911275587.6A CN201911275587A CN111061508B CN 111061508 B CN111061508 B CN 111061508B CN 201911275587 A CN201911275587 A CN 201911275587A CN 111061508 B CN111061508 B CN 111061508B
- Authority
- CN
- China
- Prior art keywords
- cache list
- access
- executing
- java card
- current access
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30003—Arrangements for executing specific machine instructions
- G06F9/3004—Arrangements for executing specific machine instructions to perform operations on memory
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
- G06F12/0875—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches with dedicated cache, e.g. instruction or stack
Abstract
The application discloses a Java card and a performance optimization method thereof. The Java card comprises a microprocessor and an RAM, an object cache list meeting an object effective identification mechanism is stored in the RAM, and the microprocessor executes a performance optimization method. The method comprises the steps of establishing an object cache list according to an object effective identification mechanism; traversing the object cache list when accessing an object; if the access object is in the object cache list, the corresponding data related to the access object in the object cache list is used for executing a subsequent code program; and if the current access object is not in the object cache list, analyzing the current access object, executing a subsequent code program by using related data obtained by analyzing the current access object, and caching the current access object and the related data thereof into the object cache list when judging that the current access object meets an object effective identification mechanism. The method and the device can obviously improve the execution efficiency of frequently accessed objects in the Java card and optimize the performance.
Description
Technical Field
The application relates to the field of smart card storage, in particular to a Java card and a performance optimization method thereof.
Background
The Java Card is a smart Card that runs Java Card programs. The Java Card needs to frequently access an object when running a Java Card program, and when the existing Java Card accesses the object, the reference (object index) of the object needs to be acquired first, and then the reference is analyzed so as to acquire a series of information of the object; taking an array object as an example, when accessing the array object, the Java card needs to obtain information such as the array type, the array size, the array address, and the location of the array.
Since the access of the objects in the Java card is very frequent and the parsing process of the objects is very tedious, the frequent parsing of the objects will tend to slow down the execution efficiency of the Java card.
At present, in order to reduce the operation of frequently analyzing an access object by a Java card, a reference of the last access object is recorded in the Java card, and the Java card directly uses related data of the last saved analysis object when the object is accessed again next time, so that the object does not need to be repeatedly analyzed. However, this method is only applicable to the case where the last access object is the same as the current access object, and the use is very limited, so the improvement of the execution efficiency of the Java card is also very limited. This approach simply fails to improve the execution efficiency of the card when encountering a scenario where multiple objects cross-access. Therefore, an optimization method capable of efficiently improving the performance of the Java card is needed to solve the problem that the Java card frequently parses the access object.
Disclosure of Invention
The application provides a Java card performance optimization method, which comprises the following steps:
creating an object cache list according to an object effective identification mechanism;
traversing the object cache list when accessing an object;
if the access object is in the object cache list, the corresponding data related to the access object in the object cache list is used for executing a subsequent code program;
and if the current access object is not in the object cache list, analyzing the current access object, executing a subsequent code program by using related data obtained by analyzing the current access object, and caching the current access object and the related data thereof into the object cache list when judging that the current access object meets an object effective identification mechanism.
The method for optimizing the performance of the Java card, wherein the object effective identification mechanism includes an object commonly used in a coding habit, an array class object, and an object of the application itself.
The method for optimizing the performance of the Java card comprises the following steps that an object reference, analyzed object information and an object environment are stored in the object cache list; the object environment comprises an address of the object, a starting address of a page where the object is located, an ending address of the page where the object is located, a position of a first byte in the page, a region where the object is located, and segment information of the region where the object is located.
The method for optimizing the performance of the Java card, wherein the creating of the object cache list specifically includes: creating a global object cache list according to an object effective identification mechanism, and storing object information which is accessed recently and meets the object effective identification mechanism in the global object cache list; and storing the accessed object and the data analyzed by the object into an object cache list if the accessed object is judged to meet the object effective identification mechanism in the program execution process.
The Java card performance optimization method described above, wherein for creating the global object cache list, when accessing an object, specifically includes the following sub-steps:
judging whether the current access object is the same as the last access object, if so, directly executing subsequent codes by using the last access object information, otherwise, executing the following operation;
traversing the object cache list, then judging whether the current access object is in the global object cache list, if so, directly executing subsequent codes by using object related information corresponding to the current access object stored in the cache list, otherwise, executing the following operation;
and analyzing the access object, and executing a subsequent code program by using the relevant data of the access object obtained by analysis.
The Java card performance optimization method as described above, wherein, for the global object cache list, when the class where the object is located is garbage-recovered, the deleted object in the global object cache list is cleared 0, and the cached object subsequent to the cleared position is moved forward, at this time, the empty position in the cache region is at the end of the cache region, and the object is placed in the empty position when a new object needs to be added to the cache list for subsequent access.
The method for optimizing the performance of the Java card, wherein the creating of the object cache list specifically includes: the method for creating the object cache list according to the object effective identification mechanism specifically comprises the following steps: traversing all byte codes of the method to be accessed, screening the accessed object by an object effective identification mechanism, storing the object meeting the object effective identification mechanism into an object cache list, and setting a corresponding mark for whether the object is analyzed in the object cache list.
The Java card performance optimization method as described above, wherein, for the object cache list of the creation method, when accessing the object, the following sub-steps are specifically included:
traversing the object cache list and judging whether the current access object is in the method object cache list, if so, executing the following operation, otherwise, analyzing the current access object, and executing a subsequent code program by using the relevant data of the current access object obtained by analysis;
judging whether the access object is accessed for the first time or not according to the analyzed mark corresponding to the access object, if so, executing the following operation, otherwise, directly executing a subsequent code program by using the corresponding relevant data of the access object in the object cache list;
analyzing the access object, caching the related data analyzed by the access object into an object cache list, and setting the analyzed mark corresponding to the access object.
The method for optimizing the performance of the Java card includes clearing, for the method object cache list, an index of the method object cache list after the program executes to exit the method.
The present application also provides a Java card, including: a microprocessor and a random access memory; and storing an object cache list meeting an object effective identification mechanism in the random access memory, and executing the Java card performance optimization method by the microprocessor.
The beneficial effect that this application realized is as follows: by adopting the Java card performance optimization method provided by the application, a certain number of objects which are accessed recently and meet the object effective identification mechanism and relevant data obtained by analyzing the objects are cached by establishing the global cache list or the method cache list, so that repeated analysis work on the cached objects can be reduced when the objects are accessed, the information and the environment of the used objects can be quickly obtained, the execution efficiency of frequently accessed objects in the Java card can be obviously improved, the performance is optimized, and particularly, the performance optimization effect is more obvious for frequently accessed non-static objects.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments described in the present invention, and other drawings can be obtained by those skilled in the art according to the drawings.
Fig. 1 is a Java card performance optimization method provided in an embodiment of the present application;
FIG. 2 is a flowchart illustrating the detailed operation of accessing objects when creating a global object cache list;
FIG. 3 is a flowchart illustrating the detailed operation of accessing objects when creating a method object cache list;
fig. 4 is a schematic diagram of a Java card according to the second embodiment of the present application.
Detailed Description
The technical solutions in the embodiments of the present invention are clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, not all, embodiments of the present invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
Example one
As shown in fig. 1, an embodiment of the present application provides a method for optimizing Java card performance, including the following steps:
optionally, a storage space is created in advance in the RAM storage area of the Java card, and is used to store an object cache list that has been accessed recently and identified that may be accessed subsequently frequently, and a certain number of object references meeting an object identification condition, parsed object information, and object environments (i.e., object-related data) are stored in the object cache list, where the object environments include, but are not limited to, an address of an object, a start address of a page where the object is located, an end address of a page where the object is located, a location of a first byte in the page, a region where the object is located, segment information of the region where the object is located, and the like;
for example, the object cache list is shown in the following table:
| caching content of objects | Size of cache object (bytes) | Caching meaning of objects |
| AreaRef | 2 | Object index |
| Addr | 2 | Real address of object |
| BBAddr | 2 | Starting address of page where object is located |
| BEAddr | 2 | End address of page where object is located |
| BPos | 2 | Location of page first byte |
| AreaDom | 1 | Area of object |
| Seg | 1 | Segment information of region where object is located |
TABLE 1
Alternatively, the object cache list may be stored in one or two lists: storing the reference of the object and the analyzed related data of the object by using a list, wherein when the object is to be accessed, the obtained object index is sequentially compared with the object references stored in the cache list, and whether the same object references exist in the cache list is judged; storing the reference of the object and the resolved object related data in two areas by using two cache lists, and enabling the reference of the object and the related data of the object to be in one-to-one correspondence, sequentially comparing the obtained object indexes with the object references when the object is to be accessed, judging whether the same object references exist, if so, finding the object data corresponding to the object references according to the corresponding relation, and if not, respectively putting the reference and the resolved object data into the cache lists after the card resolves the object data.
In the embodiment of the present application, the object information stored in the object cache list satisfies an object effective identification mechanism, where the object effective identification mechanism may be an object commonly used in an encoding habit (for example, an array object used by a storage APDU that is used at high frequency in the encoding habit), an array class object (an array class object that is accessed in a code execution process), an object of an application (an object member of the application), and the like; and storing the object to be cached in the object cache list only after the object to be cached meets the preset identification condition, so that the validity of the object in the object cache list is ensured.
In addition, a cache space is opened up in advance to store an object cache list in Java, and the object cache list is dynamically created when a Java program is executed, wherein the object cache list comprises at least one item of a global object cache list and an access method object cache list which are dynamically created, namely, the global object cache list or a method object cache list can be independently established in the actual use process, or a method combining the global object cache list and the method object cache list can be adopted;
if the global object cache list is selected to be dynamically established, storing object information which is accessed recently and meets an object effective identification mechanism in the object cache list; storing the accessed object and data analyzed by the object into an object cache list if the accessed object is judged to meet an object effective identification mechanism in the program execution process;
if the dynamic creation of the access method object cache list is selected, traversing all byte codes of the method to be accessed, screening the accessed object by an object effective identification mechanism, and storing the object meeting the object effective identification mechanism into the object cache list; optionally, the objects are sorted in the object cache list according to the sequence of the access times from small to large, and the cache list established in this way is a cache stack with the priority of the access times, so that the subsequent traversal of the cache list is more efficient; in addition, whether the object is analyzed and set with a corresponding mark in the object cache list or not is judged, if the object in the method to be accessed is accessed for the first time, the object index is analyzed to obtain object information (including object attribute and object environment information), the analyzed mark is set, and if the object in the method to be accessed is not accessed for the first time, the analyzed object information is directly used for executing a subsequent code program;
it should be noted that, after the corresponding object information is obtained from the object cache list, in order to save the time for copying data, the queried object and the analyzed object information thereof may also be directly assigned to the global variable for use.
Referring back to fig. 1, in step 120, when accessing the object, traversing the object cache list and determining whether the object accessed this time is in the object cache list, if yes, executing a subsequent code program by using the relevant data corresponding to the object accessed this time in the object cache list, otherwise, executing step 130;
in this embodiment, in the process of executing the subsequent code program, the step 120 is returned to be executed when the next object is accessed.
For establishing a global object cache list, and storing a certain amount of recently accessed object information satisfying an object valid identification mechanism in the global cache list, referring to fig. 2, when accessing an object, the Java card performs the following operations:
and step 230, analyzing the access object, and executing a subsequent code program by using the data related to the access object obtained by analysis.
For the object cache list for establishing the access method, the object and its related data are stored in the method object cache list, which are satisfied with the object effective identification mechanism in the method to be accessed, referring to fig. 3, when accessing the object, the Java card performs the following sub-steps:
step 310, traversing an object cache list and judging whether the current access object is in a method object cache list, if so, executing step 320, otherwise, analyzing the current access object, and executing a subsequent code program by using the relevant data of the current access object obtained by analysis;
specifically, the analyzed mark corresponding to the access object is judged, if the analyzed mark is not set, the access object is called for the first time, and if the analyzed mark is set, the access object is called for the non-first time;
caching the current access object and related data thereof into an object cache list and then setting an analyzed mark corresponding to the current access object;
the object cache list of the access method is created by traversing byte codes in the method, finding out objects meeting object identification conditions from the byte codes, and storing the objects into the object cache list of the access method, so that when the current access object is judged to be in the method cache list and is accessed for the first time, the current access object is shown to be the object meeting the object identification conditions, the current access object is directly analyzed, and the current access object and related data thereof are cached into the object cache list.
In the embodiment of the application, the speed of traversing the object cache list is determined by the depth of the cache list and the traversing mode; the depth of the cache list is the maximum object data number of the cache list, and the depth value can be set according to needs under certain conditions;
for example, in order to quickly execute the read-write operation of data, the developed cache list is preferably stored in the RAM area, and on the premise that the remaining space of the RAM area meets the product requirement, the time consumption for searching the cache list is less than the time consumption for analyzing the object, so that when the time consumption for searching a certain number of objects is basically the same as the time consumption for analyzing one object, the number of the searched objects is the maximum value of the stack depth of the cache list; in addition, the number of objects in the cache list can also be estimated according to the number of objects commonly used in the program, for example, 10 pieces of information of the objects which have been accessed recently are set.
Referring back to fig. 1, step 130, analyzing the access object, executing a subsequent code program by using the relevant data of the access object obtained by the analysis, and judging whether the access object meets an object effective identification mechanism, if so, caching the access object and the relevant data thereof into an object cache list, otherwise, continuing to execute the subsequent code program, and returning to step 120;
after the access object is analyzed, if the access object meets the object identification condition, namely the access object meets the condition of storing the access object into the object cache list, the access object and the relevant data obtained by analyzing the access object are stored into the object cache list, so that the access object can be conveniently used when the access object is accessed next time;
when an object cache list is updated, data storage is carried out according to a certain rule, if an idle area exists in the object cache list, the current access object and related data thereof are sequentially stored in the idle area, if no idle area exists in the object cache list, a stored reference is deleted according to a preset rule, and then the reference object accessed this time is added, for example, according to a first-in first-out rule or an object index which replaces an access pointer points to currently, for example, the cache list can store N objects, the index of the position of each object is 0-N-1, when a new object reference needs to be added, according to the first-in first-out rule, the object reference at the position 0 is emptied, the subsequent N-1 references are sequentially moved forward by one position, and the position with the index of N-1 is left out to be used for storing the newly added reference index; and if the object reference of the position which is accessed recently is emptied according to the object rule pointed by the access pointer in the replacement cache list, and the reference to be added is put into the position.
In the embodiment of the application, the life cycle of the object cache list starts from the execution of the program and is terminated when the class where the object is located needs to be garbage-recovered or the method is accessed, and the method access is terminated when the method access is finished; when the class where the object is located needs to be garbage-recovered, the method further includes recovering the object cache list, and specifically includes:
for the global object cache list, clearing 0 the reference of the deleted object in the cache list, and advancing the reference of the cached object after the clearing position, wherein the vacant reference position in the cache region is at the end of the cache region, and the reference is put into the vacant position when a new reference object needs to be added into the cache list for subsequent access;
for the way of establishing the object cache list of the current access method, when the method is executed, the object indexes in the cache list are cleared by 0.
Example two
Referring to fig. 4, a second embodiment of the present application provides a Java card, including a microprocessor and a RAM (random access memory), where an object cache list satisfying an object effective identification mechanism is stored in the RAM; the microprocessor is used for executing the Java card performance optimization method described in the first embodiment.
Corresponding to the Java card performance optimization method in fig. 1 to fig. 4, an embodiment of the present application further provides a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the computer program performs the steps of the above initialization method.
Specifically, the storage medium can be a general-purpose storage medium, such as a removable disk, a hard disk, or the like, and when the computer program on the storage medium is executed, the power-down prevention smart card operating method can be executed.
In the embodiments provided in the present application, it should be understood that the disclosed apparatus and method may be implemented in other ways. The above-described embodiments of the apparatus are merely illustrative, and for example, the division of the units is only one logical division, and there may be other divisions when actually implemented, and for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection of devices or units through some communication interfaces, and may be in an electrical, mechanical or other form.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, functional units in the embodiments provided in the present application may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit.
The functions, if implemented in the form of software functional units and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present application or portions thereof that substantially contribute to the prior art may be embodied in the form of a software product stored in a storage medium and including instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk or an optical disk, and other various media capable of storing program codes.
It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus once an item is defined in one figure, it need not be further defined and explained in subsequent figures, and moreover, the terms "first", "second", "third", etc. are used merely to distinguish one description from another and are not to be construed as indicating or implying relative importance.
Finally, it should be noted that: the above-mentioned embodiments are only specific embodiments of the present application, and are used for illustrating the technical solutions of the present application, but not limiting the same, and the scope of the present application is not limited thereto, and although the present application is described in detail with reference to the foregoing embodiments, those skilled in the art should understand that: those skilled in the art can still make modifications or changes to the embodiments described in the foregoing embodiments, or make equivalent substitutions for some features, within the technical scope of the present disclosure; such modifications, changes or substitutions do not depart from the spirit and scope of the present disclosure, which should be construed in light of the above teachings. Are intended to be covered by the scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.
Claims (8)
1. A Java card performance optimization method is characterized by comprising the following steps:
creating an object cache list according to an object effective identification mechanism; the object effective identification mechanism is specifically used for checking that the object to be cached meets a preset identification condition;
traversing the object cache list when accessing an object;
if the access object is in the object cache list, the corresponding data related to the access object in the object cache list is used for executing a subsequent code program;
if the current access object is not in the object cache list, analyzing the current access object, executing a subsequent code program by using related data obtained by analyzing the current access object, and caching the current access object and the related data thereof into the object cache list when judging that the current access object meets an object effective identification mechanism;
creating the object cache list specifically includes: creating a method object cache list or a global object cache list according to an object effective identification mechanism;
the method for creating the object cache list specifically comprises the following steps: firstly traversing all byte codes of the object to be accessed, screening the accessed object by an object effective identification mechanism, storing the object meeting the object effective identification mechanism into a method object cache list, and setting a corresponding mark for whether the object is analyzed in the method object cache list;
creating a global object cache list, specifically: storing object information which is accessed recently and meets an object effective identification mechanism in a global object cache list; and storing the accessed object and the data analyzed by the object into a global object cache list if the accessed object is judged to meet the object effective identification mechanism in the program execution process.
2. The method for optimizing Java card performance as claimed in claim 1, wherein the predetermined recognition condition includes objects commonly used in coding habits, array class objects, and objects of the application itself.
3. The Java card performance optimizing method of claim 1, wherein the object cache list stores object references, parsed object information, and object environments; the object environment comprises an address of the object, a starting address of a page where the object is located, an ending address of the page where the object is located, a position of a first byte in the page, a region where the object is located, and segment information of the region where the object is located.
4. The Java card performance optimization method according to claim 3, wherein for creating the global object cache list, when accessing the object, the following sub-steps are specifically included:
judging whether the current access object is the same as the last access object, if so, directly executing subsequent codes by using the last access object information, otherwise, executing the following operation;
traversing the global object cache list, then judging whether the current access object is in the global object cache list, if so, directly executing subsequent codes by using object related information corresponding to the current access object stored in the cache list, otherwise, executing the following operation;
and analyzing the access object, and executing a subsequent code program by using the relevant data of the access object obtained by analysis.
5. The method for optimizing the performance of the Java card according to claim 4, wherein for the global object cache list, when the class where the object is located is garbage-recovered, the deleted object in the global object cache list is cleared by 0, and the cached object following the cleared position is moved forward, and at this time, the empty position in the cache region is at the end of the cache region, and the object is placed in the empty position when a new object needs to be added to the global object cache list for a subsequent access.
6. The Java card performance optimization method of claim 1, wherein for creating a method object cache list, when accessing an object, the following sub-steps are specifically included:
traversing the method object cache list and judging whether the current access object is in the method object cache list, if so, executing the following operation, otherwise, analyzing the current access object, and executing a subsequent code program by using the data related to the current access object obtained by analysis;
judging whether the access object is accessed for the first time or not according to the analyzed mark corresponding to the access object, if so, executing the following operation, otherwise, directly executing a subsequent code program by using the corresponding relevant data of the access object in the object cache list;
analyzing the access object, caching the relevant data analyzed by the access object into a method object cache list, and setting the analyzed mark corresponding to the access object.
7. The Java card performance optimizing method of claim 6, wherein for the method object cache list, the index of the method object cache list is cleared when the program execution exits the method.
8. A Java card, comprising: a microprocessor and a random access memory; storing an object cache list satisfying an object valid identification mechanism in the random access memory, the microprocessor executing the Java card performance optimization method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911275587.6A CN111061508B (en) | 2019-12-12 | 2019-12-12 | Java card and performance optimization method thereof |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911275587.6A CN111061508B (en) | 2019-12-12 | 2019-12-12 | Java card and performance optimization method thereof |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111061508A CN111061508A (en) | 2020-04-24 |
| CN111061508B true CN111061508B (en) | 2022-05-20 |
Family
ID=70300681
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911275587.6A Active CN111061508B (en) | 2019-12-12 | 2019-12-12 | Java card and performance optimization method thereof |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111061508B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111562921B (en) * | 2020-07-16 | 2020-10-13 | 飞天诚信科技股份有限公司 | Method and equipment for optimizing byte codes of Java card |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP1739559A2 (en) * | 2005-06-20 | 2007-01-03 | Giesecke & Devrient GmbH | Processing of error events for a portable data carrier |
| CN102591787A (en) * | 2011-12-19 | 2012-07-18 | 北京握奇数据系统有限公司 | Method and device for data processing of JAVA card |
| CN104350478A (en) * | 2012-07-30 | 2015-02-11 | 甲骨文国际公司 | System and method for object deletion in persistent memory using bitmap windows |
| CN106201893A (en) * | 2016-07-21 | 2016-12-07 | 恒宝股份有限公司 | A kind of Java bytecode debugger and adjustment method |
| CN110287695A (en) * | 2019-06-25 | 2019-09-27 | 恒宝股份有限公司 | A kind of management method of Java card and its temporary object |
-
2019
- 2019-12-12 CN CN201911275587.6A patent/CN111061508B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP1739559A2 (en) * | 2005-06-20 | 2007-01-03 | Giesecke & Devrient GmbH | Processing of error events for a portable data carrier |
| CN102591787A (en) * | 2011-12-19 | 2012-07-18 | 北京握奇数据系统有限公司 | Method and device for data processing of JAVA card |
| CN104350478A (en) * | 2012-07-30 | 2015-02-11 | 甲骨文国际公司 | System and method for object deletion in persistent memory using bitmap windows |
| CN106201893A (en) * | 2016-07-21 | 2016-12-07 | 恒宝股份有限公司 | A kind of Java bytecode debugger and adjustment method |
| CN110287695A (en) * | 2019-06-25 | 2019-09-27 | 恒宝股份有限公司 | A kind of management method of Java card and its temporary object |
Non-Patent Citations (1)
| Title |
|---|
| Java智能卡平台及其优化技术展望;王同洋等;《信息科技》;20101031;全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111061508A (en) | 2020-04-24 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110321344B (en) | Information query method and device for associated data, computer equipment and storage medium | |
| US20040205044A1 (en) | Method for storing inverted index, method for on-line updating the same and inverted index mechanism | |
| US20160232186A1 (en) | Method and system for database partition | |
| US8977626B2 (en) | Indexing and searching a data collection | |
| CN107577436B (en) | Data storage method and device | |
| CN107851108B (en) | Matching documents using bit vector search index | |
| US11567681B2 (en) | Method and system for synchronizing requests related to key-value storage having different portions | |
| CN102231168B (en) | Method for quickly retrieving resume from resume database | |
| CN108475266B (en) | Matching fixes to remove matching documents | |
| CN103019887A (en) | Data backup method and device | |
| CN104216992A (en) | Information processing method and device | |
| CN108334951A (en) | For the pre- statistics of the data of the node of decision tree | |
| US20220138203A1 (en) | Method and system for searching a key-value storage | |
| CN114547095A (en) | Data rapid query method and device, electronic equipment and storage medium | |
| CN111061508B (en) | Java card and performance optimization method thereof | |
| US9164978B2 (en) | Identifying objects within a multidimensional array | |
| CN111913913A (en) | Access request processing method and device | |
| CN101295312B (en) | Method for presenting data by table | |
| US9087087B2 (en) | Performing index scans in a database | |
| CN113805864A (en) | Project engineering generation method and device, electronic equipment and storage medium | |
| CN113704260A (en) | Data storage method and system based on improved LSM tree structure | |
| CN112015791A (en) | Data processing method and device, electronic equipment and computer storage medium | |
| CN116339898B (en) | Page content display method and device | |
| CN111831691B (en) | Data reading and writing method and device, electronic equipment and storage medium | |
| CN113641681B (en) | Space self-adaptive mass data query method |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |