Patent Application
20240303106
Embodiments relate generally to computer programming, and more particularly to efficiently managing state in execution of software on a computing device.
In programs that involve objects with changing attributes, typically the attribute values are described collectively as ‘state.’ State data is required to be computed, stored, and retrieved depending on rules and conditions set by the programmers, and some state needs to affect a program's output in real-time. For instance, the price on a store UI needs to be updated when the user changes the quantity of items they are purchasing. When the functions that compute state are complex and depend on each other, computing output state efficiently and correctly in real time can become challenging and error prone, especially as program requirements change.
Described herein is a method and device for effectively tracking and storing interdependent state.
In one embodiment, a method of tracking state data on a computer is described, the method including the steps of initializing an action set, initializing a pending set, wherein the pending set comprises a set of changed watchable data, iteratively determining whether the pending set is empty, and based on a determination that the pending set is not empty, removing an item from the set of changed watchable data, and determining whether the removed item is a watch object. The method may further include, based on a determination that the removed item is a watch object, retrieving a previously computed value of the watch object, computing a new value of the watch object, comparing the previously computed value of the watch object with the new value and based on a determination that the computed value of the watch object has changed or based on the determination that the removed item is not a watch object, may further include adding new dependent items which depend on the removed item to the pending set, removing any dependency links to the new dependent items, removing any watch objects with no dependencies from the pending set and adding all actions to the action set that are triggered when the removed item changes. The method may further include performing each action in the action set. In some embodiments, the actions in the action set are performed once the pending set is empty.
In some embodiments, the method may include assigning a priority order for each item in the pending set wherein removing an item from the pending set is based upon the priority order of each item in the pending set.
In some embodiments, the method may include assigning the priority order based on a computed evaluation cost for the item.
In some embodiments, the assigned priority order for each item is determined by selecting an item, estimating an evaluation cost for the selected item, determining a priority value for each item which the selected item depends on, and creating a priority value for the selected item based on the sum of the evaluation cost of the selected item and the greatest priority value of the items which the selected item depends on.
In some embodiments the method includes creating a dependency link between a dependency and a dependent, determining whether the priority order of the dependent is less than or equal to the priority order of the dependency, and upon a determination that the priority order of the dependent is less than or equal to the dependency, setting the priority order of the dependent to be greater than the priority order of the dependency. In some embodiments, the dependency link is stored in addressable memory. In some embodiments the method includes evaluating the priority order of each subsequent dependent which depends on the aforementioned dependent and adjusting the priority order of a subsequent dependent upon a determination that the subsequent dependent has a priority order that is greater than the aforementioned dependent.
In some embodiments the method includes determining an affected count of an item, wherein the affected count reflects an impact of a change in architecture of a watch graph which includes the item. In some embodiments. the method includes determining that an item with an affected count of 0 has a dependency whose value has changed, and in response to the determination that the dependency has changed, associating a flag with the item.
In some embodiments, the method includes removing any watch objects with no dependencies from the pending set as well as removing watch objects whose only dependencies are other watch objects with no dependencies.
In another embodiment, a device is provided, where the device includes a memory, a processor, and a computer program stored on the memory and operable on the processor, wherein the processor, when running the computer program, is configured to initialize an action set, initialize a pending set, wherein the pending set comprises a set of changed watchable data, iteratively determine whether the pending set is empty, and based a determination that the pending set is not empty, remove an item from the set of changed watchable data, determine whether the removed item is a watch object, based on a determination that the removed item is a watch object, retrieve a previously computed value of the watch object, compute a new value of the watch object, compare the previously computed value of the watch object with the new value, and based on a determination that the computed value of the watch object has changed or based on the determination that the removed item is not a watch object the processor is further configured to add new dependent items which depend on the removed item to the pending set, remove any dependency links to the new dependent items, remove any watch objects with no dependencies from the pending set, and add all actions to the action set that are triggered when the removed item changes. The processor may be further configured to perform each action in the action set. In some embodiments, the processor is configured to perform each action in the action set based upon a determination that the pending set is empty.
In some embodiments, the processor is further configured to assign a priority order for each item in the pending set, where the processor is configured to base its removal of an item from the pending set upon the priority order of each item in the pending set.
In some embodiments, the processor is configured to assign the priority order based on a computed evaluation cost for the item.
In some embodiments, the processor is configured to determine the assigned priority order for each item by selecting an item, estimating an evaluation cost for the selected item, determining a priority value for each item which the selected item depends on, and creating a priority value for the selected item based on the sum of the evaluation cost of the selected item and the greatest priority value of the items which the selected item depends on.
In some embodiments, the processor further is configured to create a dependency link between a dependency and a dependent, determine whether the priority order of the dependent is less than or equal to the priority order of the dependency, upon a determination that the priority order of the dependent is less than or equal to the dependency, set the priority order of the dependent to be greater than the priority order of the dependency. In some embodiments, the dependency link is stored in addressable memory.
In some embodiments, the processor is further configured to evaluate the priority order of each subsequent dependent which depends on the dependent and
In some embodiments the processor is further configured to determine an affected count of an item, wherein the affected count reflects an impact of a change in architecture of a watch graph which includes the item.
In some embodiments, the processor is further configured to determine that an item with an affected count of 0 has a dependency whose value has changed, and in response to the determination that the dependency has changed, associating a flag with the item.
In some embodiments, the processor being configured to remove any watch objects with no dependencies from the pending set further comprises the processor being configured to remove watch objects whose only dependencies are other watch objects with no dependencies.
The components in the figures are not necessarily to scale, emphasis instead being placed upon illustrating the principles of the disclosure. Like reference numerals designate corresponding parts throughout the different views. Embodiments are illustrated by way of example and not limitation in the figures of the accompanying drawings, in which:
The present disclosure provides systems, devices, and methods used to circumvent the use of complex code to keep track of state data, which is error prone and may involve frequently re-computing the state. For example, in an environment where the price of a shopping cart depends on: the type of items in the cart, the number of items in the cart, whether an item is on sale, whether an item is associated with a coupon, etc, and a current cart total is displayed, a programmer may create instances where the total of the cart is updated in an abundance of locations throughout the code. The embodiments presented below provide an approach to eliminate the programmer's task of recalculating state while still allowing them to use the state wherever and whenever it is needed. The disclosed approaches create state computations whereby unnecessary burdens and any associated unnecessarily high strain on resources of a system may be removed during operation and execution of said complex code.
Embodiments herein depict that by embedding state management into the programming language itself, as opposed to managing state data through written code, the system may enable programmers to simply describe the computation of a state by writing the functions or expressions that compute it, and then receive state change events as needed with minimal recalculation. This involves tracking the interdependencies between the functions as they are executed, caching their computed values, and updating dependent functions whenever a computed value has changed. That is, the present disclosure provides a method which allows a computing device to determine which functions are necessary to run while not running other functions which may not affect a state of a desired object.
The present embodiments provide a method by which coding by a programmer is simplified via a language which stores and automatically recalculates desired data rather than requiring a programmer to write code that does so manually. This increases coding efficiency, by reducing the amount of time a programmer requires to write certain code.
Referring to
Issues which may contribute to the ability of the illustrated executable program to efficiently monitor a state value include: writing of the dependent functions by a programmer, the number of loops that a function may have to run during execution—which could change while running a program, the number of branches or called functions within a function, and the way in which state computation is organized with respect to the state interdependencies. These variables increase the complexity of a system to correctly monitor and accurately compute a state in a real-time environment.
Although a simplified example, the quantity of dependent states in State graph 100 also demonstrates the possibility that intermediate state may have multiple options for order of evaluation, and since both computationally expensive and inexpensive functions may be involved, logic to determine the evaluation order may affect how much work the computer needs to do, as further discussed in
Referring to
A watch object may be conceptually considered as a grouping of (a) a method with which a value can be calculated, (b) specific parameter or input values necessary to perform the calculation, and (c) the resulting output value. In some embodiments, a watch object is capable of being associated with the sources of additional input information that is needed during the calculation (such as the result of a function call) and the consumers of the resulting output value in a way that facilitates recalculation when desired. A programmer may identify data as watchable data or identify an object as a watch object to leverage the processes described in the embodiments herein.
A common example of a watch object is a function call that takes a specific set of argument values. Another example may be a simple counter that increments when any of its dependencies change. Each watch object keeps a cached version of its value to minimize re-computation. Referring now to
In some embodiments, by reevaluating each watch object within a watch object graph, the present disclosure ensures a watch object graph remains acyclic, for easily traversing it in order of dependencies, and for preferring to call less expensive functions when there are options of what to evaluate first. The present disclosure also ensures that the efficiency of the program is higher than a scenario where the disclosed embodiments are not executed, and contemplates that information within a state graph is handled according to factors such as the burden a function may have on a processor.
An embodiment of the present disclosure provides a feature which determines and assesses an estimation of evaluation time of each watch object, stores those estimated evaluation times of each watch object and evaluates their values according to the estimated evaluation times.
Referring to
Particularly, process 400: initializes an action set (step 402), initializes a pending set to a set of changed watchable data (step 404); evaluates whether the pending set is empty (step 406), repeatedly removes an item from the pending set 408; and determines whether the removed item is a watch object 410. If the item is a watch object, process 400 reevaluates the removed item and stores any new dependencies at step 412. The process then determines if the watch object's value has changed at step 414. If the value has not changed, the process returns to step 406 to determine if the pending set is empty. If the watch object's value has changed, or if it was determined at step 410 that the item was not a watch object, the process adds all watch objects that depend on the item to the pending set at step 415. The process destroys dependency links between the added watch objects and all their dependencies that may become irrelevant upon the computation of the added watch objects at step 416. This may leave some watch objects with no dependents, a scenario which is discussed in more detail in
In the depicted embodiment, the “pending set” is a set of all items of watchable data that are to be evaluated. The “action set” is a set of actions to be performed after all evaluations have been completed.
Referring to
Referring to
In some embodiments, when more than one item is present in pending set 430 (as depicted in
Referring to
Continuing to
When the state evaluation process is complete, objects with no remaining references (such as watch object C 426) may be destroyed or kept in a cache as desired in case their values are needed again. In some embodiments, an external system that monitors, tracks, relies upon, or otherwise utilizes the value of a watch object may hold its own references to it, preventing its destruction.
In some embodiments, it may also be possible to evaluate multiple watch objects in a pending set 430 in parallel, although careful handling is necessary when the evaluation of one watch object in the pending set 430 requires the evaluated value of another.
In some embodiments, each watch object is given an “evaluation order” value 510, with the requirement that each watch object's evaluation order is greater than its dependencies'. The watch object with the lowest evaluation order of the pending set is then prioritized first. Each watch object's evaluation order may be set, for instance, to the highest evaluation order of its dependencies plus an estimated cost of the time it may take to evaluate the watch object. As a result, cheaper functions have lower evaluation orders and are preferred to be evaluated first. As shown in the diagram 500, watch objects B 504 and C 506 both depend on A 502, but because C 506 has a cost of 20 and B 504 only has a cost of 2, B's 504 evaluation order is set to a lower value.
In other embodiments, a priority may include simply picking the cheapest function from the pending set, which may result in evaluating watch objects before their dependencies when both are in the pending set. In this embodiment, this method may be suitable if the dependencies are evaluated recursively and handled as they are evaluated (by adding their dependents to the pending set and removing themselves from the pending set as usual).
This inclusion of each function's evaluation cost allows a program to efficiently evaluate states within a program and allows real-time tracking of those states to be more efficient.
System 600a-600c shows how an evaluation order may also be used to ensure that a watch object graph has no cycles. The first diagram 610 is an example watch object graph architecture including six watch objects arranged in an arbitrary order with arbitrary dependency links 421. When a dependency link 421 is created, as in diagram 620, the present embodiment checks if the evaluation order 624 of the dependency is less than the evaluation order of the dependent 622. In this case it is not (2>1). To correct this, the present disclosure sets the evaluation order 622 of the dependent higher (diagram 630), and then ensures that its dependents' evaluation orders 632 are higher than itself. This involves a search through the graph 630. If the search reaches either of the original watch objects, a cycle is detected.
For example, when actions 641 are added to and removed from the watch object graph (650-680), an “affected count” 642 of the dependency (a watch object linked to and above the dependent watch object or action) watch objects 646 are incremented and decremented by 1 respectively. (This can be separate from the reference count of the watch objects if they are referred to from elsewhere, such as a variable in the program.) In some embodiments, the affected count 642 may be evaluated recursively.
Generally speaking, when an action 641 is added, the affected count 642 of its dependencies is incremented. If those watch objects' affected count 642 changed from 0 to 1, the affected count of their dependencies would be incremented. Similarly, when an action 641 is removed, the affected count of its dependencies is decremented.
For example, action 641 of graph 650 is removed in graph 660. Accordingly, the affected counts of dependencies 652 and 654 are decremented by 1 resulting in an affected count of 1 for watch object 652 and 0 for watch object 654. If, for example, any of the dependencies (652 and 654) went from 1 to 0, as does 654 in graph 660, the affected count 642 of their dependencies (656) would also be decremented as illustrated in graph 670.
Referring to
In some embodiments, the affected count 642 is also decremented or incremented when a dependency link 421 from a watch object to another with a nonzero affected count is destroyed or created. This can cause affected count to change during graph evaluation.
Referring to watch object graph 690, when a dependency of a watch object 646 with an affected count of 0 changes, in this example dependency watch object 692, the watch object is not inserted into the pending set 430. Instead, the watch object 697 is marked as “out of date” or “needing evaluation,” 696 (as depicted in watch object graph 695) and all of its dependents 699 (and their dependents, etc.) are recursively marked, depicted in watch object graph 695. In another embodiment, rather than recursively marking a watch object and all of its dependents, watch objects may be marked iteratively or by other processes that would be apparent to one of skill in the art. By precluding a dependent from entering a pending set 430, it avoids unnecessary evaluations of watch objects 646 since it is known that no actions 641 can result from any changes to those watch objects. If the value of a “needs eval” 696 watch object 646 is requested at a later time, it may be recalculated at that time. In some embodiments, the creation or reestablishment of dependency links 421 may further occur accordingly.
In some embodiments, if a watch object's affected count 642 is set to 0 when it is already in the pending set 430 (see discussion of
Referring to
Table 1 provides a WantWaterEffects function labeled with a “watchable” keyword, an InWater function, and an InThirdPerson function. In the water effect coding example, a state of whether an object is in a water environment is dictated by InWater function and a state of whether the object is displayed in a third person view by function InThirdPerson. Water effect coding example, using the watchable label, may, using the present disclosure, store the returned value data of WantWaterEffects, InWater, and InThirdPerson into addressable memory.
Referring to
Below timeline 802 a first state change 810 represents an instance where a program vehicle enters a wet environment, and a reevaluation of a state 822 occurs simultaneously. Reevaluation of state 822, under the conditions ‘in water’, and ‘third person’, the result is an ‘on’ state. In water duration 812 represents a period where WantWaterEffects( ) returns true based on timeline 802, and so a graphical representation depicting water droplets 804 is correctly displayed.
At a second state change 814 a player enters a first-person perspective and a corresponding reevaluation of state 824 simultaneously occurs due to a change of the value of InThirdPerson( ) 710. As depicted an in-water duration 812 ends when a second state change 814 occurs and a first-person perspective is graphically depicted showing an environment without third-person water effects (an ‘off’ state) (as shown in thumbnail 806).
In a third state change 816 a vehicle exits a wet environment and a reevaluation of state 826 occurs returning an ‘out of water’ and ‘first person’, resulting in an ‘off’ state (as shown in thumbnail 808).
At a fourth state change 818, a player selects a third-person perspective, where a reevaluation of state 828 occurs returning ‘out of water’ and ‘third person’ resulting in an ‘off’ state. Accordingly, a graphical representation shows a third-person perspective 820 in a dry environment (i.e., without water effects).
In the second example solution 800 of
Referring to Table 2, an example drone movement program code is listed. Drone movement program code simulates the movement of a set of drones and waits until all of the drones are in a given circular zone (defined in member function Drone::IsInZone( ) by providing zonePos and zoneRadius). Each drone's position (pos) is stored as a watch object whose value is an <X,Y,Z> position in 3D space. The “watchable” function “Drone::IsInZone( )” calculates whether a drone is in the circle defined by zonePos and zoneRadius. The “watchable” function “AllDronesInZone( )” calculates whether all of the drones in the “watcharray” “drones” are in the calculated zone, by calling their aforementioned IsInZone( ) method. A watcharray is an array which can be watched for changes (e.g., if contents are added, removed, or reordered); that is, an array for which the size and order can be treated as watchable data. The “Simulate( )” function initializes three drones with functions that depend on the “watchable” variable “time”, and then waits until AllDronesInZone( ) returns true. The “time” variable and the “drones” watcharray are examples of watchable data. Resuming the Simulate( ) function is an example of an action that can result from changes to watchable data.
Referring to
Example watch object graph 950 further includes a watchable variable 952, where the watchable variable 952 represents a variable holding a time value which affects drone “pos” watch objects 956 and drone IsInZone( ) function calls 958. The watch object graph 950 illustrates watch objects representing calls to those functions which may affect an object's state, such as in this program whether a drone is within Zone. The watch objects in the graph and their relative dependencies are represented by data in memory and, in some embodiments, may be constructed dynamically as AllDronesInZone( ) is called and the values of the above function calls are computed.
As stated previously, dependency watch objects drones.pos 956 provide a position coordinate of a drone at a given time, as computed by their “watchexpr” functions in Simulate( ). Function AllDronesInZone 960 is calculated using dependent function calls 958 as illustrated and describes whether all dependent drone locations are within the designated zone region.
Drones watch object graph 950 further includes Drones watcharray 954, where watcharray 954 is linked to AllDronesInZone 960. Here code (not illustrated) that manipulates watcharray 954 is connected to cause reevaluation of AllDronesInZone 960. In some embodiments, when functions are marked as watchable, all calls to the watchable functions including the parameters passed are stored in addressable hashes. In Drones watch object graph 950, when the contents of watcharray 954 changes, according to the present disclosure, AllDronesInZone 960 function is reevaluated and links to AllDronesInZone 960, such as links from drone IsInZone 958, are severed and then reconnected, as function(s) drone.IsInZone 958 are re-executed. Accordingly, interdependent links to drone.IsInZone 958 may also be severed and reevaluated. This feature of the present disclosure provides a method of updating a Boolean value of AllDronesInZone 960, for example, so that dependent actions such as a resume action 962 are triggered with more reliable and efficient calculations in a real-time environment.
In the embodiment depicted in
Referring to
When the signals are sent to reevaluate watchable function instances 1012, their evaluation order (as described in
According to the disclosure, using features highlighted above, state data is managed in a more efficient manner where signal sources 1002 provide signals to watchable functions 1012 where management of interdependent function links, for example, create a signal flow 1000, where 1) dependency mapping may be simplified, 2) function execution may be managed more efficiently ensuring that unnecessary executions of functions are minimized, and 3) program coding may also be simplified.
Referring to
In other embodiments after the updated object state is stored, all links from other parent functions are removed and no other functions linked to the watchable item are executed.
Referring to
In at least one embodiment, computing device 1200 may include one or more processor(s) 1202, one or more memory element(s) 1204, storage 1206, a bus 1208, one or more network processor unit(s) 1210 interconnected with one or more network input/output (I/O) interface(s) 1212, one or more I/O interface(s) 1214, and control logic 1220. In various embodiments, instructions associated with logic for computing device 1200 can overlap in any manner and are not limited to the specific allocation of instructions and/or operations described herein.
In at least one embodiment, processor(s) 1202 is/are at least one hardware processor configured to execute various tasks, operations and/or functions for computing device 1200 as described herein according to software and/or instructions configured for computing device. Processor(s) 1202 (e.g., hardware processor(s)) can execute any type of instructions associated with data to achieve the operations detailed herein. In one example, processor(s) 1202 can transform an element or an article (e.g., data, information) from one state or thing to another state or thing. Any of potential processing elements, microprocessors, digital signal processor, baseband signal processor, modem, PHY, controllers, systems, managers, logic, and/or machines described herein can be construed as being encompassed within the broad term ‘processor.’
In at least one embodiment, memory element(s) 1204 and/or storage 1206 is/are configured to store data, information, software, and/or instructions associated with computing device 1200, and/or logic configured for memory element(s) 1204 and/or storage 1206. For example, any logic described herein (e.g., control logic 1220) can, in various embodiments, be stored for computing device 1200 using any combination of memory element(s) 1204 and/or storage 1206. Note that in some embodiments, storage 1206 can be consolidated with memory element(s) 1204 (or vice versa), or can overlap/exist in any other suitable manner.
In at least one embodiment, bus 1208 can be configured as an interface that enables one or more elements of computing device 1200 to communicate in order to exchange information and/or data. Bus 1208 can be implemented with any architecture designed for passing control, data and/or information between processors, memory elements/storage, peripheral devices, and/or any other hardware and/or software components that may be configured for computing device 1200. In at least one embodiment, bus 1208 may be implemented as a fast kernel-hosted interconnect, potentially using shared memory between processes (e.g., logic), which can enable efficient communication paths between the processes.
In various embodiments, network processor unit(s) 1210 may enable communication between computing device 1200 and other systems, entities, etc., via network I/O interface(s) 1212 (wired and/or wireless) to facilitate operations discussed for various embodiments described herein. In various embodiments, network processor unit(s)1210 can be configured as a combination of hardware and/or software, such as one or more Ethernet driver(s) and/or controller(s) or interface cards, Fibre Channel (e.g., optical) driver(s) and/or controller(s), wireless receivers/transmitters/transceivers, baseband processor(s)/modem(s) and/or other similar network interface driver(s) and/or controller(s) now known or hereafter developed to enable communications between computing device 1200 and other systems, entities, etc. to facilitate operations for various embodiments described herein. In various embodiments, network I/O interface(s) 1212 can be configured as one or more Ethernet port(s), Fibre Channel ports, any other I/O port(s), and/or antenna(s)/antenna array(s) now known or hereafter developed. Thus, the network processor unit(s) 1210 and/or network I/O interface(s) 1212 may include suitable interfaces for receiving, transmitting, and/or otherwise communicating data and/or information in a network environment.
I/O interface(s) 1214 allow for input and output of data and/or information (wired and/or wireless) with other entities that may be connected to computing device 1200. For example, I/O interface(s) 1214 may provide a connection to external devices such as a keyboard, keypad, a touch screen, and/or any other suitable input device now known or hereafter developed. In some instances, external devices can also include portable computer readable (non-transitory) storage media such as database systems, thumb drives, portable optical or magnetic disks, and memory cards. In still some instances, external devices can be a mechanism to display data to a user, such as, for example, a computer monitor, a display screen, or the like.
In various embodiments, control logic 1220 can include instructions that, when executed, cause processor(s) 1202 to perform operations, which can include, but not be limited to, providing overall control operations of computing device; interacting with other entities, systems, etc. described herein; maintaining and/or interacting with stored data, information, parameters, etc. (e.g., memory element(s), storage, data structures, databases, tables, etc.); combinations thereof; and/or the like to facilitate various operations for embodiments described herein.
The programs described herein (e.g., control logic 1220) may be identified based upon application(s) for which they are implemented in a specific embodiment. However, it should be appreciated that any particular program nomenclature herein is used merely for convenience; thus, embodiments herein should not be limited to use(s) solely described in any specific application(s) identified and/or implied by such nomenclature.
In various embodiments, entities as described herein may store data/information in any suitable volatile and/or non-volatile memory item (e.g., magnetic hard disk drive, solid state hard drive, semiconductor storage device, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM), application specific integrated circuit (ASIC), etc.), software, logic (fixed logic, hardware logic, programmable logic, analog logic, digital logic), hardware, and/or in any other suitable component, device, element, and/or object as may be appropriate. Any of the memory items discussed herein should be construed as being encompassed within the broad term ‘memory element’. Data/information being tracked and/or sent to one or more entities as discussed herein could be provided in any database, table, and register, list, cache, storage, and/or storage structure: all of which can be referenced at any suitable timeframe. Any such storage options may also be included within the broad term ‘memory element’ as used herein.
Note that in certain example implementations, operations as set forth herein may be implemented by logic encoded in one or more tangible media that is capable of storing instructions and/or digital information and may be inclusive of non-transitory tangible media and/or non-transitory computer readable storage media (e.g., embedded logic provided in: an ASIC, digital signal processing (DSP) instructions, software [potentially inclusive of object code and source code], etc.) for execution by one or more processor(s), and/or other similar machine, etc. Generally, memory element(s) 1204 and/or storage 1206 can store data, software, code, instructions (e.g., processor instructions), logic, parameters, combinations thereof, and/or the like used for operations described herein. This includes memory element(s) 1204 and/or storage 1206 being able to store data, software, code, instructions (e.g., processor instructions), logic, parameters, combinations thereof, or the like that are executed to carry out operations in accordance with teachings of the present disclosure.
In some instances, software of the present embodiments may be available via a non-transitory computer useable medium (e.g., magnetic or optical mediums, magneto-optic mediums, CD-ROM, DVD, memory devices, etc.) of a stationary or portable program product apparatus, downloadable file(s), file wrapper(s), object(s), package(s), container(s), and/or the like. In some instances, non-transitory computer readable storage media may also be removable. For example, a removable hard drive may be used for memory/storage in some implementations. Other examples may include optical and magnetic disks, thumb drives, and smart cards that can be inserted and/or otherwise connected to a computing device for transfer onto another computer readable storage medium.
It is contemplated that various combinations and/or sub-combinations of the specific features and aspects of the above embodiments may be made and still fall within the scope of the disclosure. Accordingly, it should be understood that various features and aspects of the disclosed embodiments may be combined with or substituted for one another in order to form varying modes of the disclosed disclosure. Further, it is intended that the scope of the present disclosure is herein disclosed by way of examples and should not be limited by the particular disclosed embodiments described above.
This application claims priority to provisional application 63/489,735, filed Mar. 10, 2023, the contents of which are herein incorporated by reference in their entirety.
| Number | Date | Country | |
|---|---|---|---|
| 63489735 | Mar 2023 | US |
