Method and apparatus for controlling a buffer

Abstract

This disclosure relates to methods and apparatus for controlling a buffer. A processor-implemented method includes the steps of: incrementing the value of the counter information in response to determining whether the buffer is in use and in response to input data being input to the buffer; locking the buffer in response to the increment of the counter information value; decrementing the value of the counter information in response to completion of reading the input data from the buffer; and unlocking the buffer in response to the decrement of the counter information value.

Description

Technical Field

[0001] This disclosure relates to methods and apparatus for controlling buffers. Background Technology

[0002] The vehicle's software components are responsible for the functions of applications related to autonomous driving technology. Due to the multiple software (SW) components, data resources need to be shared among them. Resource sharing between software components should ensure data integrity. For data integrity, shared resources can be implemented based on the parts related to the software component, or the scheduling of software components can be defined during the compilation phase. Concurrent resource sharing between software components leads to conflicts in access to resources.

[0003] As autonomous driving applications become more complex, the number of service modules (SW) components also increases. Methods for partitioning main segments or static scheduling established during the compilation phase have limitations that can reduce performance or make it difficult to handle high complexity when implementing application architecture.

[0004] Using a master segment can increase the number of service nodes (SWs) waiting to access shared resources, and static scheduling can halve the CPU time occupied by SWs for a sustained period. For example, when two nodes operate within a 10ms timeframe, each node might occupy 5ms of CPU. However, when the number of nodes increases to five, each node might only occupy 2ms of CPU. Furthermore, as complexity increases, it becomes difficult to apply input / output synchronization between nodes. Summary of the Invention

[0005] The present invention is provided to present, in a simplified form, the selection of concepts further described in the following detailed description. The present invention is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

[0006] In general, this paper provides a processor-implemented method comprising the steps of: incrementing a count information in response to determining whether a buffer is in use and in response to input data being input to the buffer; locking the buffer in response to the increment of the count information; decrementing the count information in response to completion of reading the input data in the buffer; and unlocking the buffer in response to the decrement of the count information.

[0007] The buffer may be one of a plurality of buffers, the plurality of buffers may include a queue, and the method may include the following steps: a first node inputs first data of the input data into a first buffer in the queue; a second node reads the first data; and the first node inputs second data of the input data into a second buffer in the queue.

[0008] The buffer may include multiple nodes, each of which is configured to perform an operation within the same time period. The method may include the following steps: a first node among the multiple nodes inputs first data of the input data into the buffer; a second node and a third node among the multiple nodes read the first data from the buffer; the second node inputs second data of the input data into the buffer; and the third node synchronizes and processes the first data and the second data.

[0009] The buffer may include multiple nodes, a first node of the multiple nodes is configured to perform an operation within the same first time period, and a second node of the multiple nodes is configured to perform an operation within a second time period, which is different from the first time period. The method may include the following steps: synchronizing first data input by the first node in the input data, and processing only the synchronization data of the input data related to the synchronization of the first node in the second data input by the second node.

[0010] The buffer may be one of multiple buffers, which may include a first queue identified by a first parameter and a second queue identified by a second parameter, and the method may include the following steps: a first node inputs first data from the input data into the first queue and the second queue; a second node reads first data from the first queue; and a third node reads second data from the second queue.

[0011] The method may include the following steps: after the input data is input into the buffer, integrity information regarding the integrity of the input data is input into the buffer, the integrity information being one or more of a cyclic redundancy check (CRC), a timestamp, or a frame count.

[0012] The buffer may include a circular buffer, and the method may include the following steps: a second node reads first data input by a first node into a first buffer within the circular buffer; and the first node inputs second data into a second buffer within the circular buffer.

[0013] The buffer may include data input by the node and an indicator indicating whether the input data is in the buffer, and the data input to the buffer may be output based on the indicator.

[0014] The buffer may include one or more queues or circular buffers, and the number of buffers in the queue or the size of the circular buffer may be adjusted based on the number of nodes sharing the buffer.

[0015] In general, this document provides an electronic device comprising: one or more processors configured to execute instructions; a memory storing the instructions, and the execution of the instructions configuring the one or more processors to: increment a value of counter information in response to determining whether a buffer is in use and in response to input data being input to the buffer; lock the buffer in response to the increment of the value of the counter information; decrement the value of the counter information in response to completion of reading the input data in the buffer; and unlock the buffer in response to the decrement of the value of the counter information. Attached Figure Description

[0016] Figure 1 A method for managing and scheduling buffers according to an implementation is shown.

[0017] Figure 2 A method for managing and scheduling buffers according to an implementation is shown.

[0018] Figure 3 A method for managing and scheduling buffers according to an implementation is shown.

[0019] Figure 4 A method for managing and scheduling buffers according to an implementation is shown.

[0020] Figure 5 A method for managing and scheduling buffers according to an implementation is shown.

[0021] Figure 6 A method for ensuring data integrity according to an embodiment is shown.

[0022] Figure 7 A method for guaranteeing performance according to an embodiment is shown.

[0023] Figure 8 A method for guaranteeing performance according to an embodiment is shown.

[0024] Figure 9 An apparatus for controlling a buffer according to an embodiment is shown.

[0025] Throughout the accompanying drawings and detailed description, unless otherwise described or provided, the same or similar reference numerals may be construed as referring to the same or similar elements, features, and structures. The drawings may not be drawn to scale, and for clarity, illustration, and convenience, the relative dimensions, scale, and depiction of elements in the drawings may be exaggerated. Detailed Implementation

[0026] The following detailed description is provided to assist the reader in gaining a full understanding of the methods, apparatus, and / or systems described herein. However, various changes, modifications, and equivalents of the methods, apparatus, and / or systems described herein will be apparent after understanding the disclosure of this application. For example, the sequences of operations described herein are merely examples and are not limited to those set forth herein, but may be changed as will become apparent after understanding the disclosure of this application, except for operations that must occur in a specific order.

[0027] The features described herein may be embodied in different forms and should not be construed as limited to the examples described herein. Rather, the examples described herein are provided merely to illustrate some of the many possible ways of implementing the methods, apparatus, and / or systems described herein, which will become apparent upon understanding the disclosure of this application.

[0028] The advantages and features of this disclosure, as well as methods for achieving these advantages and features, will become clear from the following detailed description of embodiments taken in conjunction with the accompanying drawings. However, this disclosure is not limited to the embodiments disclosed herein, but will be implemented in various forms. Embodiments of this disclosure are provided to fully disclose the disclosure, and those skilled in the art will fully understand the scope of this disclosure. This disclosure will be defined only by the scope of the appended claims. Furthermore, the terminology used in this specification is for explaining the embodiments and not for limiting the disclosure.

[0029] Terms such as first, second, A, B, (a), and (b) may be used herein to describe components. Each of these terms is not used to define the nature, order, or sequence of the corresponding component, but only to distinguish the corresponding component from other components. For example, a first component may be referred to as a second component, and similarly, a second component may be referred to as a first component.

[0030] Throughout the specification, when a component is described as "connected to" or "attached to" another component, it may be directly "connected to" or "attached to" that other component, or there may be one or more other components in between. In contrast, when an element is described as "directly connected to" or "directly attached to" another element, there may be no other elements in between.

[0031] In the description of the embodiments, when any element is described as being formed above or below another element, such a description includes cases where the two elements are formed in direct contact with each other and cases where the two elements are in indirect contact with each other and one or more other elements are sandwiched between the two elements. Furthermore, when an element is described as being formed above or below another element, such a description can include cases where one element is formed on the upper or lower side relative to the other element.

[0032] Unless the context clearly indicates otherwise, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well. It will be further understood that, when used herein, the terms “comprising” and / or “including” specify the presence of the said feature, integer, step, operation, element, and / or component, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.

[0033] Figure 1 A method for managing and scheduling buffers according to an implementation is shown.

[0034] The buffer control method according to the embodiments relates to a method for scheduling multiple-input multiple-output (MIMO) operations in writing and reading data between buffers and nodes. The buffer control method includes methods for managing and scheduling buffer control so that nodes providing multiple software components related to vehicle functions and / or autonomous driving applications can safely and efficiently access data resources in the buffers. Hereinafter, the buffer control method according to the embodiments may be abbreviated as the method according to the embodiments. Data read from the buffer to process a node's job, or data stored (written) in the buffer as a result of processing a node's job, can be referred to as a resource. One or more nodes can write data to a shared buffer or read data from a shared buffer. Data can be referred to as a resource or a shared resource.

[0035] The method according to the implementation may include a method of locking and unlocking the buffer based on count information about the use of the buffer.

[0036] like Figure 1 The diagram illustrates how multiple nodes, such as three nodes, manage and schedule a buffer. According to the method described in this embodiment, the buffer (memory) can be locked or unlocked to protect operations that write or read data between nodes within the buffer. Buffer locking refers to the operation of controlling access to specific data to prevent conflicts when multiple data are input into the buffer. Conversely, buffer unlocking refers to the operation of releasing the buffer lock and allowing access to the data.

[0037] For example, in the case where node 1 (the first node) writes data to the buffer and node 2 (the second node) and node 3 (the third node) read data from the buffer, node 1 according to the implementation can be locked to prevent node 1 from rewriting data to the buffer, and can be unlocked when node 2 and node 3 have finished reading data.

[0038] Each node has a time period and a processing time. A time period refers to the periodic time a node spends completing one job and starting the next. Processing time refers to the time a node spends processing one job. The time periods and / or processing times between nodes can vary depending on the node's function. For example, Figure 1 Nodes 1 through 3 can have a time interval of 33ms, with Node 1 having a processing time of 30ms, Node 2 having a processing time of 20ms, and Node 3 having a processing time of 5ms.

[0039] Reference Figure 1 In (a), node 1 can write data to the buffer while processing a job, and notify nodes 2 and 3 of event information indicating the result of the buffer write. Nodes 2 and 3 increment the value of the count information (buffer_use_count) indicating whether the buffer is in use by "1" to begin processing their jobs and read the written data from the buffer (memory). The method according to the implementation locks the buffer based on the incremented count information (buffer_use_count).

[0040] refer to Figure 1 In (b), nodes 2 and 3 complete job processing according to each processing time and decrease the value of the buffer use count (buffer_use_count) by "1". The method according to the implementation method unlocks the buffer based on the decreased use count.

[0041] Figure 2 A method for managing and scheduling buffers according to an implementation is shown.

[0042] The method according to the embodiment may also include a method of providing a pipeline to guarantee maximum application performance by queuing data transmitted between nodes in the buffer. For example, a queue-based buffer pipeline may include multiple buffers. A queue-based buffer pipeline may include buffers with multiple depths. The queue including the buffers according to the embodiment may operate in a first-in, first-out (FIFO) manner.

[0043] Reference Figure 2In step (a), node 1 can write data into buffer 1 (the first buffer), where the buffer usage count (buffer_use_count) is "0", to process the job, and notify nodes 2 and 3 of an event indicating that data has been written to buffer 1. Nodes 2 and 3, having received the event, can begin processing the job and increment the buffer usage count (buffer_use_count) by "1". According to the implementation method, buffer 1 can be placed in a queue on the pipeline based on the incremented count (buffer_use_count).

[0044] refer to Figure 2 (b) Node 1 can write data to buffer 2 (the second buffer) in the queue, where the buffer usage count (buffer_use_count) is "0", to process the next job. Node 1 can notify nodes 2 and 3 of event information indicating whether buffer 2 is in use. Nodes 2 and 3 can complete job processing based on the data in buffer 1 and decrement the buffer usage count (buffer_use_count) by "1". According to the implementation method, buffer 2 can be placed in the queue on the pipeline based on the decreased count (buffer_use_count).

[0045] According to the implementation, the queue-shaped buffer is used in parallel, thereby accessing data resources and performing write / read operations without conflicts.

[0046] Therefore, the method according to the implementation method can guarantee the performance of applications based on shared resources. Figure 2 The queue-shaped buffers described herein can be configured as circular buffer structures. For example, N buffers can be configured to transfer data between nodes, as the input (write) data and output (read) data of the buffers are read and written in a circular buffer. Due to the queue and / or circular buffers, when data is written to a buffer and data written by another node is consumed, a node can simultaneously write data to another buffer with a queue and / or circular structure. Therefore, data contention is prevented, thus providing maximum operational performance through parallel processing.

[0047] Figure 3 A method for managing and scheduling buffers according to an implementation is shown.

[0048] The method according to the implementation may also include a method for synchronizing multiple input data among nodes with the same operating time period.

[0049] Nodes 1 through 3 can have the same time interval. The description will assume that each node has a time interval of 33ms. Figure 3 The example shown.

[0050] refer to Figure 3 In (a), node 1 can process the job, write data to the buffer, and notify nodes 2 and 3 as an event message that the buffer writing is complete. Nodes 2 and 3 can then read the data stored in the buffer. In this case, the buffer source will be referred to as "N".

[0051] Because nodes 1 through 3 share the same time period, node 1 does not write other data to the same buffer (buffer source: N) before nodes 2 and 3 read data from the buffer. Node 2 can read data stored in the buffer (buffer source: N), process the job, and write related data to the buffer (buffer source: N). Data conflicts are prevented because node 3 has already read data stored in the buffer (buffer source: N). Node 2 can notify node 3 as an event message that the buffer write (buffer source: N) is complete. Node 1 can write additional data to the buffer during node 2's job. The additional buffer source can be referred to as "N-1" compared to the buffer source of the previous time period.

[0052] Reference Figure 3 (b) Node 3 can synchronously write data to buffer source N of node 2 and data to buffer source N of node 1 for use in job processing on node 3. Node 3 can increment the value of the buffer use count (buffer_use_count) by "1", indicating that data for nodes 1 and 2 has been read from the buffer. Additionally, key information about other buffer sources can be deleted / (discarded) from the parameter map. Key information can refer to values ​​used to identify buffer sources. Parameter maps can refer to maps used to store additional information about buffers. For example, key values ​​used to identify buffer sources can be stored in parameter maps. When reading multiple input data for multiple nodes, the method according to the implementation can perform synchronization between multiple input data based on the same key information of the buffer sources.

[0053] Figure 4 A method for managing and scheduling buffers according to an implementation is shown.

[0054] The method according to the implementation may also include a method for processing multiple input data between nodes with different operation periods to ensure the stability of the algorithm during application operation.

[0055] The following description will assume that nodes 1 through 3 have the same time period (e.g., 33ms) and node 4 has a different time period (e.g., 10ms).

[0056] Reference Figure 4 (a) Operations and references from node 1 to node 3 Figure 3 The operation described in (a) is the same. Because nodes 1 through 3 have the same time period, node 3, which receives the result (output) data from nodes 1 and 2, can synchronize and process the result (output) data from nodes 1 and 2 based on the key information of the same buffer source. Furthermore, node 4 can process the job with a different time period and processing time than nodes 1 and 2. Node 4 can write the job processing data to the buffer source Q.

[0057] Reference Figure 4 (b) Operations and references of nodes 1 to 3 Figure 3 The operation described in (b) is the same. Because nodes 1 and 2 have the same time period, node 3 can synchronize and process the data of nodes 1 and 2. Node 3 does not synchronize the data of node 4, which has a different time period, with the data of nodes 1 and 2. Instead of synchronizing all the output data of node 4 (i.e., the data stored in buffer source Q) with the output data of nodes 1 and 2 (i.e., the data stored in buffer source N) every 10ms time period, node 3 reads the data of node 4 stored in buffer source Q at the timed interval of reading the data of buffer source N. Node 3 does not use the previously stored data of buffer source Q, and the key information of buffer source Q at different time periods (e.g., N-2) is discarded in the parameter mapping. Node 3 can read the output data of node 4 from buffer source Q and increment the value of the buffer use count information (buffer_use_count) by "1".

[0058] Figure 5 A method for managing and scheduling buffers according to an implementation is shown.

[0059] The method according to the implementation may also include methods for distinguishing shared resources between nodes to lock or unlock buffers and for synchronizing buffer data between nodes to cope with high application complexity.

[0060] like Figure 5 As shown, a high level of application complexity can arise when multiple output data are provided from node 3 to multiple nodes (e.g., node 5 and node 6) and the multiple nodes (e.g., node 5 and node 6) have different processing times than each other. Node 5 and node 6 can read the output data of node 3 from the buffer (i.e., the data written to the buffer) based on different parameters related to the multiple output data of node 3.

[0061] For example, refer to Figure 5 Node 3 can manage the result data related to the job processing of Node 3 in the buffer based on the output queue identified by parameter 1 and the output queue identified by parameter 2, and provide it to each of Node 5 and Node 6.

[0062] Node 3 can process the job and write data to buffer 1, where the buffer usage count (buffer_use_count) in the output queue (buffer queue) identified by parameter 1 is "0". Node 3 can also process the job and write data to buffer 13, where the buffer usage count (buffer_use_count) in the output queue (buffer queue) identified by parameter 2 is "0". Node 3 can provide data from buffer 1 to node 5 and data from buffer 3 to node 6. When node 5 finishes reading data from buffer 1, buffer 1 is re-entered into the output queue identified by parameter 1. When node 6 finishes reading data from buffer 3, buffer 3 is re-entered into the output queue identified by parameter 2.

[0063] Therefore, even with increased application requirements and complexity, the method implemented can still provide multiple output data based on multiple buffer queues.

[0064] Figure 6 A method for ensuring data integrity according to an embodiment is shown.

[0065] Figure 6 It is shown in the reference Figure 1 The methods described for managing and scheduling buffers include methods to ensure data integrity.

[0066] refer to Figure 1 According to the implementation method, the buffer can be locked or unlocked by increasing or decreasing the value of the buffer use count (buffer_use_count) to occupy shared resources (buffers), and data distortion can be prevented when shared resources are consumed in a read-only manner. For example, the buffer can be locked when the buffer use count (buffer_use_count) increases from "0" to "1", and the buffer can be unlocked when the buffer use count (buffer_use_count) decreases from "1" to "0".

[0067] Besides reference Figure 1 In addition to the described operations, refer to Figure 6According to the method of the implementation, data can be recorded (written) in a shared resource (buffer), and the integrity information of the data can be recorded together with cyclic redundancy check (CRC), source timestamp and / or source count, and the integrity information can be verified to detect whether the data is distorted immediately before the data is used (read).

[0068] For example, node 1 can write data to buffer 1, and additionally write data integrity information to the buffer. The data integrity information, according to the implementation, may include at least one of CRC, timestamp, or frame count. When node 2 and / or node 3 reads data written to buffer 1 by node 1, they can detect whether errors exist in the data written to buffer 1 based on the data integrity information. Node 2 and / or node 3 can read the data in buffer 1, calculate a CRC value, and identify whether an error has occurred in the shared resource and / or during the reading of the shared resource by comparing the calculated CRC value with the recorded CRC value, comparing the timestamp value of an event preceding the current event with the timestamp value of the current event, or comparing the frame count value of an event preceding the current event with the frame count value of the current event.

[0069] Figure 7 A method for guaranteeing performance according to an embodiment is shown.

[0070] The method according to the implementation can identify whether to synchronize and read data input from multiple nodes based on the presence of a writer of input (write) data in a dynamic indicator buffer to ensure performance. The method according to the implementation can prevent performance degradation due to the absence of data input in some of the multiple nodes.

[0071] For example, Figure 7 The diagram illustrates the operation for node 3 to read buffered data (buffer source N) input by nodes 1 and 2, where node 3 synchronously reads data input to the buffer by nodes 1 and 2 because nodes 1 and 2 have the same time frame. In this case, when node 2 is absent, node 3 can read only the data input by node 1 from the buffer. To prevent performance degradation due to node 3 waiting for data input when node 3 exists to read data input from multiple nodes such as nodes 1 and 2, but the input data of some nodes 1 and 2 is absent, the node can additionally input a writer (or indicator) indicating the presence of data into the buffer when data is input. The writer according to the embodiment can indicate the presence of data based on a true or false value or based on a value of "0" or "1". The method according to the embodiment can read data only from the node associated with the writer indicating the presence of data.

[0072] Figure 8A method for guaranteeing performance according to an embodiment is shown.

[0073] The method according to the implementation can dynamically adjust the circular buffer (buffer queue, see below) Figure 2 The amount of data space used for operations within the unit is determined to ensure performance and optimize resource usage.

[0074] refer to Figure 8 It can be assumed that nodes 1 through 4 exist with the same time interval. Nodes 2 and 4 read data written by node 1 from the buffer, node 3 reads data written by node 2, and node 4 reads data written by node 3. When nodes 1 through 4 share a circular buffer (or buffer queue) with three buffer sizes, the buffer occupancy time of node 1 inevitably increases to consume the time intervals of all nodes 1, 2, 3, and 4, and therefore the data space in the circular buffer may be insufficient. Node 1 processes one job per time interval (e.g., 33ms), and nodes 2 through 4 also process one job per equal time interval, where only three buffers lack memory to occupy the data of node 1 in the buffer queue until node 4 reads the data.

[0075] The method described in this implementation allows for the dynamic increase or decrease of the size of the circular buffer (buffer queue) based on the relationships between multiple nodes. The minimum size of the circular buffer (buffer queue) can be set to be equal to or greater than the number of nodes sharing the buffer.

[0076] Figure 9 An apparatus for controlling a buffer according to an embodiment is shown.

[0077] The buffer control device 9000 according to an embodiment may include a memory 9001 and / or a processor 9002. The memory 9001 may store instructions related to the buffer control method according to an embodiment. The processor 9002 may be configured to execute the buffer control method according to an embodiment.

[0078] Let's refer to each other. Figure 1 The processor can be configured to: read data input to the buffer and increment a counter indicating whether the buffer is in use; lock the buffer based on the incremented counter; decrement the counter when the data input to the buffer has been completely read; and unlock the buffer based on the decremented counter.

[0079] The processor can execute a buffer control method. The buffer control method may include the following steps: reading data input to the buffer and incrementing a counter indicating whether the buffer is in use; locking the buffer based on the incremented counter; decrementing the counter when all data input to the buffer has been read; and unlocking the buffer based on the decremented counter.

[0080] Let's refer to each other. Figure 2 Regarding the buffer queue, when the buffer is a queue that includes multiple buffers, the buffer control method may further include the following steps: the second node reads the data input by the first node into the first buffer in the queue; and the first node inputs the data into the second buffer in the queue.

[0081] Let's refer to each other. Figure 3 Regarding synchronization based on the same time period, multiple nodes in a shared buffer have the same time period. The first node among the multiple nodes inputs data into the buffer, and the second and third nodes among the multiple nodes read the data input by the first node into the buffer. The second node inputs data into the buffer, and the third node synchronizes and processes the data input by the first node and the data input by the second node.

[0082] Let's refer to each other. Figure 4 In a shared buffer, the first node of multiple nodes has the same time period, the second node has a different time period than the first node, the data input to the first node is synchronized, and only the data input to the second node that is related to the synchronization of the first node can be processed.

[0083] Let's refer to each other. Figure 5 Regarding multiple queues, the buffers may include a first queue and a second queue. The first queue includes multiple buffers identified by a first parameter, and the second queue includes multiple buffers identified by a second parameter. A first node may input data into the first queue and the second queue, a second node may read data from the first queue, and a third node may read data from the second queue.

[0084] Let's refer to each other. Figure 6 Regarding integrity information, the buffer control method may further include the following steps: after data is input into the buffer, additional information about the integrity of the data is input into the buffer, wherein the information about integrity may include at least one of cyclic redundancy check (CRC), timestamp, or frame count.

[0085] Let's refer to each other. Figure 2When the buffer is a circular buffer that includes multiple buffers, the buffer control method may further include the following steps: the second node reads the data input by the first node into the first buffer in the circular buffer; and the first node inputs the data into the second buffer in the circular buffer.

[0086] Let's refer to each other. Figure 7 The buffer includes data input by the node and an indicator indicating whether data has been input into the buffer, and the data input into the buffer can be output based on the indicator.

[0087] Let's refer to each other. Figure 8 The buffer is at least one of a queue or a circular buffer, and the number of buffers included in the queue or circular buffer can be adjusted based on the number of nodes sharing the buffer.

[0088] The method and apparatus according to the embodiments provide the following technical effects.

[0089] Data integrity is ensured by protecting the memory read (or input) and write (or output) operations of data transmitted between nodes. Maximum performance is guaranteed by synchronizing node input / output at runtime and smoothly utilizing idle CPU resources through dynamic scheduling. Data integrity between nodes sharing resources is guaranteed, and high levels of application complexity are supported through input / output synchronization and dynamic scheduling.

[0090] The apparatus and method according to the embodiments protect memory read / write operations of data transmitted between nodes, thereby ensuring data integrity.

[0091] The apparatus and method according to the implementation method synchronize the input and output of the node during operation and smoothly utilize the idle resources of the CPU through dynamic scheduling, thereby ensuring maximum performance.

[0092] The apparatus and method according to the embodiments ensure data integrity among nodes sharing resources and support high levels of application complexity through input and output synchronization and dynamic scheduling.

[0093] Implementations have been described in accordance with the methods and / or apparatus, and the descriptions of the methods and apparatus may be applied complementaryly to each other.

[0094] Operations according to the embodiments described herein can be performed by a transmitting / receiving device including a memory and / or processor according to the embodiments. The memory may store programs for processing / controlling the operations according to the embodiments, and the processor may control the various operations described herein. The processor may be referred to as a controller, etc. In the embodiments, operations can be performed by firmware, software, and / or combinations thereof. Firmware, software, and / or combinations thereof may be stored in a processor or memory.

[0095] The operations according to the above embodiments can be performed by the transmitting and / or receiving devices according to the embodiments. The transmitting / receiving devices may include a transmitter / receiver configured to transmit and receive media data, a memory configured to store instructions (program code, algorithms, flowcharts, and / or data) for processing according to the embodiments, and a processor configured to control the operation of the transmitting / receiving devices.

[0096] The processor may be referred to as a controller, etc., and may correspond to, for example, hardware, software, and / or a combination thereof. Operations according to the above embodiments can be performed by the processor.

[0097] The various embodiments disclosed herein do not list all available combinations, but are used to describe representative aspects of the disclosure, and the descriptions of the various embodiments may be applied independently or in combination of two or more.

[0098] Several embodiments have been described above. However, it should be understood that various modifications can be made. For example, suitable results may be achieved if the described techniques are performed in a different order and / or if the components in the described system, architecture, apparatus, or circuit are combined in a different manner and / or replaced or supplemented by other components or their equivalents. Therefore, other embodiments are within the scope of the appended claims.

[0099] While this disclosure includes specific examples, it will be apparent upon understanding this disclosure that various changes in form and detail may be made in these examples without departing from the spirit and scope of the claims and their equivalents. The examples described herein are to be considered descriptive only and not for limiting purposes. The description of features or aspects in each example is to be considered applicable to similar features or aspects in other examples. Suitable results may be achieved if the described techniques are performed in a different order, and / or if the components in the described system, architecture, apparatus, or circuit are combined in a different manner, and / or replaced or supplemented by other components or their equivalents. Therefore, the scope of this disclosure is not limited by the specific embodiments but by the claims and their equivalents, and all variations within the scope of the claims and their equivalents are to be included in this disclosure.

[0100] Cross-reference to related applications

[0101] This application claims priority to Korean Patent Application No. 10-2025-0016575, filed on February 10, 2025, the entire disclosure of which is incorporated herein by reference for all purposes.

Claims

1. A processor-implemented method, the method comprising the following steps: The count information is incremented in response to determining whether the buffer is in use and in response to input data being input into the buffer; The buffer is locked in response to an increase in the value of the count information; The value of the count information is decreased in response to the completion of reading the input data in the buffer; and The buffer is unlocked in response to a decrease in the value of the count information.

2. The method according to claim 1, wherein, The buffer is one of multiple buffers. The plurality of buffers includes queues, and The method further includes the following steps: The first node inputs the first data of the input data into the first buffer in the queue; The first data is read by the second node; and The first node inputs the second data of the input data into the second buffer in the queue.

3. The method according to claim 1, wherein, The buffer comprises multiple nodes, each configured to perform operations within the same time period, and The method further includes the following steps: The first node among the plurality of nodes inputs the first data of the input data into the buffer; The first data is read from the buffer by the second and third nodes among the plurality of nodes; The second node inputs the second data of the input data into the buffer; and The first data and the second data are synchronized and processed by the third node.

4. The method according to claim 1, wherein, The buffer includes multiple nodes, a first node of which is configured to perform an operation within the same first time period, and a second node of which is configured to perform an operation within a second time period, which is different from the first time period. The method further includes the following steps: The first node synchronizes the first data input by the first node in the input data, and Specifically, only the synchronization data of the input data related to the synchronization of the first node in the second data input by the second node is processed.

5. The method according to claim 1, wherein, The buffer is one of multiple buffers. The plurality of buffers includes a first queue identified by a first parameter and a second queue identified by a second parameter, and The method further includes the following steps: The first node inputs the first data from the input data into the first queue and the second queue; The second node reads the first data from the first queue; and The third node reads the second data from the second queue.

6. The method according to claim 1, further comprising the following steps: After the input data is input into the buffer, integrity information regarding the integrity of the input data is input into the buffer. The integrity information includes one or more of the following: Cyclic Redundancy Check (CRC), timestamp, or frame count.

7. The method according to claim 1, wherein, The buffer includes a circular buffer, and The method further includes the following steps: The second node reads the first data input from the first node into the first buffer within the circular buffer; and The first node inputs the second data into the second buffer within the circular buffer.

8. The method according to claim 1, wherein, The buffer includes data input by the node and an indicator indicating whether the input data is in the buffer. The data input to the buffer is output based on the indicator.

9. The method according to claim 1, wherein, The buffer includes one or more queues or circular buffers, and The number of buffers in the queue or the size of the circular buffer is adjusted based on the number of nodes sharing the buffer.

10. An electronic device, the electronic device comprising: One or more processors, wherein the one or more processors are configured to execute instructions; as well as A memory that stores the instructions, wherein execution of the instructions configures the one or more processors to: The count information is incremented in response to determining whether the buffer is in use and in response to input data being input into the buffer; The buffer is locked in response to an increase in the value of the count information; The value of the count information is decreased in response to the completion of reading the input data in the buffer; and The buffer is unlocked in response to a decrease in the value of the count information.

Images