Method and system for specifying device interoperability source specifying renditions data and code for interoperable device team

• US 7,747,980 B2
• Filed: 06/08/2005
• Issued: 06/29/2010
• Est. Priority Date: 06/08/2004
• Status: Active Grant

• Current Assignee: David E. Kahn
• Original Assignee: Covia Labs, Inc.
• Inventors: Sidney, Raymond, Bernstein, Bruce, Mirabella, Richard, Pieb, Wolfgang, Illowsky, Daniel, Wenocur, Michael, Tiberi, Richard
• Primary Examiner(s): Dam; Tuan Q
• Assistant Examiner(s): DAO, THUY CHAN
• Application Number:
  US11/149,074
• Publication Number:
  US 20050289509A1
• Time in Patent Office: 1,847 Days
• Field of Search: None
• US Class Current: 717/107
• CPC Class Codes: G06F 1/3203 Power management, i.e. event-based initiation of a power-saving mode
• CPC Class Codes: G06F 11/2082 Data synchronisation
• CPC Class Codes: G06F 16/2365 Ensuring data consistency and integrity
• CPC Class Codes: G06F 21/445 by mutual authentication, e.g. between devices or programs
• CPC Class Codes: G06F 21/6218 to a system of files or objects, e.g. local or distributed file system or database
• CPC Class Codes: G06F 2209/5015 Service provider selection
• CPC Class Codes: G06F 2221/2113 Multi-level security, e.g. mandatory access control
• CPC Class Codes: G06F 2221/2149 Restricted operating environment
• CPC Class Codes: G06F 8/10 Requirements analysis; Specification techniques
• CPC Class Codes: G06F 8/20 Software design
• CPC Class Codes: G06F 8/24 Object-oriented
• CPC Class Codes: G06F 8/30 Creation or generation of source code
• CPC Class Codes: G06F 8/41 Compilation
• CPC Class Codes: G06F 8/61 Installation
• CPC Class Codes: G06F 8/63 Image based installation; Cloning; Build to order
• CPC Class Codes: G06F 8/658 Incremental updates; Differential updates
• CPC Class Codes: G06F 8/71 Version control security arrangements therefor G06F21/57; Configuration management
• CPC Class Codes: G06F 9/449 Object-oriented method invocation or resolution
• CPC Class Codes: G06F 9/4843 by program, e.g. task dispatcher, supervisor, operating system
• CPC Class Codes: G06F 9/5011 the resources being hardware resources other than CPUs, Servers and Terminals
• CPC Class Codes: G06F 9/5027 : the resource being a machine, e.g. CPUs, Servers, Terminals
• CPC Class Codes: G06F 9/5044 : considering hardware capabilities
• CPC Class Codes: G06F 9/5072 : Grid computing
• CPC Class Codes: G06F 9/54 : Interprogram communication
• CPC Class Codes: G06F 9/541 : via adapters, e.g. between incompatible applications
• CPC Class Codes: G06F 9/542 : Event management; Broadcasting; Multicasting; Notifications
• CPC Class Codes: H04L 65/1083 : In-session procedures
• CPC Class Codes: H04L 65/1094 : Inter-user-equipment sessions transfer or sharing
• CPC Class Codes: H04L 65/80 : Responding to QoS
• CPC Class Codes: H04L 67/10 : in which an application is distributed across nodes in the network software deployment G06F8/60; multiprogramming arrangements G06F9/46
• CPC Class Codes: H04L 67/104 : Peer-to-peer [P2P] networks
• CPC Class Codes: H04L 67/1068 : Discovery involving direct consultation or announcement among potential requesting and potential source peers
• CPC Class Codes: H04L 67/1072 : Discovery involving ranked list compilation of candidate peers
• CPC Class Codes: H04L 67/1095 : Replication or mirroring of data, e.g. scheduling or transport for data synchronisation between network nodes
• CPC Class Codes: H04L 67/14 : Session management for real-time applications in data packet communications networks H04L65/1066
• CPC Class Codes: H04L 67/51 : Discovery or management thereof, e.g. service location protocol [SLP] or web services
• CPC Class Codes: H04L 69/08 : Protocols for interworking; Protocol conversion
• CPC Class Codes: H04L 69/24 : Negotiation of communication capabilities
• CPC Class Codes: H04L 69/328 : in the presentation layer [OSI layer 6]
• CPC Class Codes: H04N 21/41265 : having a remote control device for bidirectional communication between the remote control device and client device unidirectional remote control device H04N21/42204
• CPC Class Codes: Y02D 10/00 : Energy efficient computing, e.g. low power processors, power management or thermal management
• CPC Class Codes: Y02D 30/00 : Reducing energy consumption in communication networks

Abstract

System, device, method, and computer program and computer program products for providing communicating between devices having similar or dissimilar characteristics and facilitating seamless interoperability between them. Computer program software and methods of and systems and devices for sharing of content, applications, resources and control across similar and dissimilar permanently or intermittently connected devices. An interoperability source or DartSource method is provided for specifying program renditions and code content and data needed for packaged interoperability application. The interoperability source extends languages constructs commonly used to specify single executable program targeted to specific device, into language and format which can also specify procedures necessary for intelligent recruitment of teams of devices and alternative renditions of the program and/or content to be used on different device platforms so that there is suitable rendition to send to run on each recruited device to carry out that device'"'"'s portion of the application.

Claims

1. A method for forming and assembling an individual self-contained pre-linked cross-device software application as an application package, each application package or portion of an application package is adapted to execute on an interoperability engine in a device and to distribute the application package or a portion of the application package to other interoperability engines in other devices over a communications link, the other devices being formed into unified teams for cooperative execution over a plurality of the teamed devices, the method comprising:

forming the application package from source materials which encapsulate a main application function code portion, a main application data portion, any optional binary encoded parts portion, and a discovery and distribution code portion; and

encoding the application package portions into a linear binary data structure of addressable parts wherein the application package includes self-contained and pre-linked elements;

the discovery and distribution code portion encoded to be operable during execution to discover capabilities and resources of a device and then to distribute executable sub-units of the application package over one or more communication links to other devices so that the distributed executable sub-units execute on a team of devices that are unified by the distributed executable sub-units to carry out the function of the application where each device in said team of devices is running a unification engine adapted for executing at least the distributed executable sub-units of the application;

each said linear binary data structure including;

(i) exactly one linear main program code part including coded instructions where the addresses of all the coded instructions are located in one linear consecutive address space, and (ii) exactly one linear main program data part including data elements and where the addresses of all the data elements are located in one linear consecutive address space;

the linear binary data structure including two or more executable sub-units made up of exactly one linear contiguous subset of the main program code part and exactly one linear contiguous subset of the main program data part, along with zero or more of said optional binary encoded parts; and

wherein all the code that embodies and carries out the function of the software application on all said teamed devices is contained in the original application package data structure before being distributed to the teamed devices.

2. The method of claim 1, where the system calls or instructions are used to connect a function logic of the software application to the following native underlying hardware and software of the device:

(a) software engine;

(b) software operating system;

(c) communications subsystem;

(d) graphics subsystem;

(e) cryptographic subsystem;

(f) security subsystem;

(g) storage, audio rendering, and or input/output subsystems;

(h) native code expressed algorithms or procedures;

(i) media compression and or decompression subsystems;

(j) data processing or database processing;

(k) device specific unique functions and capabilities exposed through application program interfaces;

(l) device specific profile information for retrieving information about the resources, content and capabilities of the device;

(m) an event queue and associated event queue management subsystem to drive the synchronous and asynchronous operations of the application across devices;

(n) user interface, text, audio, video or other transcoding or rendering operations, and or general computation operations, and or general database operations;

(o) power management, suspend/resume, and or application level error recovery from intermittent connections through the use of events to drive the sharing and cooperative operations of software, data, content and state within and or between one or more cooperating devices; and

(p) subsystems to dynamically save, configure, optimize and or send parts, packages of parts, procedures, executable images, or packages of executable images to or from physical storage, or to and from other connected devices.

3. The method of claim 1, wherein the application package includes class definitions and object implementations to provide a basis for conforming to specific runtime conventions used for event driven execution on or amongst one or more teamed devices.

4. The method of claim 1, wherein the application package includes class definitions and object implementations to ensure synchronous processing of events within an executable, and synchronized operation between devices by serializing the processing of events between parts of the software application distributed and then run on a set of cooperating devices.

5. The method of claim 1, further comprising forming the specified software application package and storing the formed specified software application package into a tangible computer readable media.

6. The method of claim 1, wherein:

the software application expresses the following;

(a) an object oriented framework and or library;

(b) source code for expressing the main code and main data used to carry out the function logic of the software application, whether to be expressed as one executable image or an integrated set of executable images;

(c) digitally expressible resources; and

(d) system calls or instruction invocations necessary for connecting the logic of the application to the native underlying hardware and software of the device(s).

7. The method of claim 1, wherein the software application package format includes:

a signature portion;

a keywords portion;

a parts portion;

a part table portion; and

a trailer portion containing the offset of the part table from the beginning of the package file.

8. The method of claim 7, wherein the parts portion further comprises:

a renditions table having renditions table records that includes;

(i) information about linear segments within the main data part and a main code part needed by the rendition that is referenced by a part ID in that record, and (ii) the starting code image address to begin execution for that rendition.

9. The method of claim 7, wherein the parts table portion includes a plurality of part table records, and each part table record further includes:

a part ID;

a content type;

a plurality of flags;

a start offset from the beginning of the file where a contiguous image of the part is found in the file;

an end offset from the beginning of the file where the contiguous image of the part is found in the file; and

at least one optional parameter.

10. The method of claim 1, wherein the framework comprises:

a master rendition;

a rendition different from the master rendition;

a gizmo;

a pointer to a parent gizmo;

at least one pointer to a child gizmo;

a setup method; and

a process method.

11. The method of claim 1, wherein the software application is configured to interoperate with a cryptographic subsystem embodied in an interoperability instruction set that is exposed for use by the software application when executed by a player or engine, and wherein the software application package handle all the security needs including cryptographic security needs.

12. The method of claim 1, wherein the method further comprises adapting the application package by including only executable sub-units portions of the application package that are operable with the discovered capabilities and resources of the discovered device, and then forming the executable sub-units so that they are adapted to discovered individual device team member heterogeneous capabilities and resources;

the discovery of the individual device team member heterogeneous capabilities and resources including;

providing an executable discovery procedure encapsulated in the application package having its own discovery portion code and discovery portion data in an address space entirely separate from that of the main program code and the main program data; and

automatically sending the discovery procedure via the communication link to a potential teamed device to execute on the potential teamed device to discover which of said executable sub-units in the application package, if any, should be sent to the potential teamed device to execute of the potential teamed device as part of the team of devices.

13. The method of claim 12, wherein the executable sub-units may include all of the application package or a sub-set of the application package having less than the entire application package.

14. The method of claim 12, wherein the executable sub-units are different sub-executable units for different teamed devices.

15. The method of claim 1, wherein each said linear binary data structure consists of:

(i) exactly one linear main program code part including coded instructions where the addresses of all the coded instructions are located in one linear consecutive address space, and (ii) exactly one linear main program data part including data elements and where the addresses of all the data elements are located in one linear consecutive address space.

16. The method of claim 1, wherein said “

all the code”

includes code for performing self-contained inspection procedures that are sent to run on candidate team devices to procedurally characterize device capabilities and resources and make a decision while running on the device as to which of the executable sub-units are to be distributed to and run on the candidate device when it becomes a teamed device.

17. The method of claim 16, wherein the characterization procedure to select teams of devices needed to carry out the function of the application, distributes only the executable sub-units needed to be present on that device to augment the capabilities and resources of the other one or teamed devices in performing the application function.

18. The method of claim 16 wherein the adaptation is carried out at least in part using Dart Renditioning.

19. The method of claim 1, wherein the function of the application is carried out by effectively running as a single event-driven run-time across the team of devices by automatically maintaining a virtual single queue of the events that drive the cross-device application package, without any one device or software component required to perform as master arbitrator of said events.

20. The method of claim 1, wherein the said interoperability engine is a DartEngine.

21. The method of claim 1, wherein the method for forming and assembling is performed by a software forming tool running on a computer device having a processor and a memory coupled to the processor and which:

(i) accesses program source code, object code and/or text or binary data as source content;

(ii) generates a single linear contiguous main program code part conforming to a single linear contiguous address space from the source content;

(iii) generates a single linear contiguous main program data part conforming to a single linear contiguous address space from the source content;

(iv) generates one or more individual linearly contiguous procedure parts, each having their own single linear code and linear data address spaces from the source content;

(v) forms a part for each said executable sub-unit that lists the parts that constitute the executable sub-unit including exactly one main program part and exactly one main program data part;

(vi) generates a directory of the parts which includes parameters used to find the start of the parts and the end of parts in the application package;

(vii) places entries for each part in the data structure;

(viii) places the data structure of parts in a location in the application package where it can be programmatically located by the interoperability engine;

(ix) adds parameters into the directory of parts entry for the main code part for each executable sub-unit identifying part that specifies the starting point and length of the main program code subset that is part of the executable sub-unit; and

(x) adds parameters into the directory of parts entry for the main data part for each executable sub-unit identifying part that specifies the starting point and length of the main program data subset that is part of the executable sub-unit.

22. The method of claim 1 wherein the cross-device application is a Dart application.

23. The method of claim 1 wherein the procedure is a DartProcedure.

24. The method of claim 1 wherein the executable sub-unit is a DartRendition.

25. The method of claim 1 wherein the linear binary data structures of addressable parts conforms to the DartFormat.

26. The method of claim 1 wherein the method is carried out by the DartTools.

27. The method of claim 1 wherein interoperability engine is a unifying DartEngine.

28. The method of claim 1 wherein the code is formed from instructions from a Dart Interoperability Instruction Set.

29. A method for forming and assembling an application package adapted to execute at least in part on a device having an interoperability engine and to distribute itself or a sub-part of itself to other devices having interoperability engines that form a team of unified devices that perform other parts of the application package for which any one of the devices does not have all the capabilities and resources required to perform the entire application function, the devices being formed into the unified teams for cooperative execution over a plurality of the teamed devices, the method comprising:

encoding the application package portions into a linear binary data structure of addressable parts wherein the application package includes self-contained and pre-linked elements, wherein the linear binary data structure of addressable parts that includes;

(i) a linear main program code part including coded instructions for performing the application function where the addresses of all the coded instructions are located in one linear consecutive address space; and

(ii) a linear main program data part including data elements for use with the application function and where the addresses of all the data elements are located in one linear consecutive address space;

(iii) a linear discovery code part operable during execution on a first device to communicate with other devices including with a second device and discover capabilities and resources of the other devices including the second device and to communicate the discovered capabilities and resources of the second device to the first device; and

(iv) a linear distribution code part operable during execution on the first device to select or assemble and communicate an executable sub-unit of the application package in response to the discovered capabilities and resources of the second device that is specifically adapted for execution on the second device in order to interoperate with the first device in a unified manner to assist in performing the application function cooperatively as a team of devices with the first device; and

wherein all the content including executable code and data encoding in the application package that embodies and carries out the function of the application on all the teamed devices is included in the original application package data structure of the first device before being distributed to the other devices forming the team of devices.

30. The method of claim 29, wherein the linear binary data structure includes two or more executable sub-units made up of exactly one linear contiguous subset of the main program code part, and exactly one linear contiguous subset of the main program data part, along with zero or more of said optional binary encoded parts.

31. The method of claim 29, wherein the method further comprises adapting the application package by including only executable sub-units portions of the application package that are operable with the discovered capabilities and resources of the discovered device, and then forming the executable sub-units so that they are adapted to discovered individual device team member heterogeneous capabilities and resources;

the discovery of the individual device team member heterogeneous capabilities and resources including;

providing an executable discovery procedure encapsulated in the application package having its own discovery portion code and discovery portion data in an address space entirely separate from that of the main program code and the main program data; and

automatically sending the discovery procedure via the communication link to a potential teamed device to execute on the potential teamed device to discover which of said executable sub-units in the application package, if any, should be sent to the potential teamed device to execute of the potential teamed device as part of the team of devices.

32. A data structure stored in a computer readable storage medium for execution on or by a plurality of connected or intermittently connected homogeneous and heterogeneous interoperability devices, the data structure configured to execute in a processor of an interoperability engine a method for forming and assembling an individual self-contained cross-device software application as an application package, where each application package or portion of an application package is adapted to execute on the interoperability engine in a device and to distribute the application package or a portion of the application package to other interoperability engines in other devices over a communications link, the other devices being formed into unified teams for cooperative execution over a plurality of the teamed devices, the method comprising:

forming the application package from source materials which encapsulate a main application function code portion, a main application data portion, any optional binary encoded parts portion, and a discovery and distribution code portion; and

encoding the application package portions into a linear binary data structure of addressable parts wherein the application package includes self-contained and pre-linked elements;

the discovery and distribution code portion encoded to be operable during execution to discover capabilities and resources of a device and then to distribute executable sub-units of the application package over one or more communication links to other devices so that the distributed executable sub-units execute on a team of devices that are unified by the distributed executable sub-units to carry out the function of the application where each device in said team of devices is running a unification engine adapted for executing at least the distributed executable sub-units of the application;

each said linear binary data structure including;

(i) one linear main program code part including coded instructions where the addresses of all the coded instructions are located in one linear consecutive address space, and (ii) one linear main program data part including data elements and where the addresses of all the data elements are located in one linear consecutive address space;

the linear binary data structure including two or more executable sub-units made up of exactly one linear contiguous subset of the main program code part and exactly one linear contiguous subset of the main program data part, along with zero or more of said optional binary encoded parts; and

wherein all the code that embodies and carries out the function of the software application on all said teamed devices is contained in the original application package data structure before being distributed to the teamed devices.

33. The data structure of claim 32, wherein the method further comprises adapting the application package by including only executable sub-units portions of the application package that are operable with the discovered capabilities and resources of the discovered device, and then forming the executable sub-units so that they are adapted to discovered individual device team member heterogeneous capabilities and resources;

the discovery of the individual device team member heterogeneous capabilities and resources including;

providing an executable discovery procedure encapsulated in the application package having its own discovery portion code and discovery portion data in an address space entirely separate from that of the main program code and the main program data; and

automatically sending the discovery procedure via the communication link to a potential teamed device to execute on the potential teamed device to discover which of said executable sub-units in the application package, if any, should be sent to the potential teamed device to execute of the potential teamed device as part of the team of devices.

34. An apparatus for forming and assembling an individual self-contained cross-device software application as an application package, each application package or portion of an application package is adapted to execute on an interoperability engine in a device and to distribute the application package or a portion of the application package to other interoperability engines in other devices over a communications link, the other devices being formed into unified teams for cooperative execution over a plurality of the teamed devices, the apparatus comprising:

a processor and a memory coupled with the processor;

an interoperability engine executing at least in part on the processor and processor coupled memory;

means for forming the application package from source materials which encapsulate a main application function code portion, a main application data portion, any optional binary encoded parts portion, and a discovery and distribution code portion;

means for encoding the application package portions into a linear binary data structure of addressable parts wherein the application package includes self contained and pre-linked elements;

means for executing the discovery and distribution code portion that is encoded to be operable during execution to discover capabilities and resources of a device and then to distribute executable sub-units of the application package over one or more communication links to other devices so that the distributed executable sub-units execute on a team of devices that are unified by the distributed executable sub-units to carry out the function of the application where each device in said team of devices is running a unification engine adapted for executing at least the distributed executable sub-units of the application; and

wherein;

each said linear binary data structure includes;

(i) one linear main program code part including coded instructions where the addresses of all the coded instructions are located in one linear consecutive address space, and (ii) one linear main program data part including data elements and where the addresses of all the data elements are located in one linear consecutive address space; and

the linear binary data structure including two or more executable sub-units made up of exactly one linear contiguous subset of the main program code part and exactly one linear contiguous subset of the main program data part, along with zero or more of said optional binary encoded parts; and

all the code that embodies and carries out the function of the software application on all said teamed devices is contained in the original application package data structure before being distributed to the teamed devices.

35. The apparatus of claim 34, wherein the apparatus further comprises:

means for adapting the application package by including only executable sub-units portions of the application package that are operable with the discovered capabilities and resources of the discovered device, and then forming the executable sub-units so that they are adapted to discovered individual device team member heterogeneous capabilities and resources;

the means for executing the discovery and distribution code portion that discovers the individual device team member heterogeneous capabilities and resources further including;

means for executing a discovery procedure encapsulated in the application package having its own discovery portion code and discovery portion data in an address space entirely separate from that of the main program code and the main program data; and

means for automatically sending the discovery procedure via the communication link to a potential teamed device to execute on the potential teamed device to discover which of said executable sub-units in the application package, if any, should be sent to the potential teamed device to execute of the potential teamed device as part of the team of devices.

36. The apparatus of claim 34, further comprising:

a tool running on the processor and a memory coupled to the processor that includes;

(i) means for accessing program source code, object code and/or text or binary data as source content;

(ii) means for generating a single linear contiguous main program code part conforming to a single linear contiguous address space from the source content;

(iii) means for generating a single linear contiguous main program data part conforming to a single linear contiguous address space from the source content;

(iv) means for generating one or more individual linearly contiguous procedure parts, each having their own single linear code and linear data address spaces from the source content;

(v) means for forming a part for each said executable sub-unit that lists the parts that constitute the executable sub-unit including exactly one main program part and exactly one main program data part;

(vi) means for generating a directory of the parts which includes parameters used to find the start of the parts and the end of parts in the application package;

(vii) means for placing entries for each part in the data structure;

(viii) means for placing the data structure of parts in a location in the application package where it can be programmatically located by the interoperability engine;

(ix) means for adding parameters into the directory of parts entry for the main code part for each executable sub-unit identifying part that specifies the starting point and length of the main program code subset that is part of the executable sub-unit; and

(x) means for adding parameters into the directory of parts entry for the main data part for each executable sub-unit identifying part that specifies the starting point and length of the main program data subset that is part of the executable sub-unit.