Computing resources

Computing resources refer to the software and hardware used to execute computing tasks, including CPU, GPU, memory, operating systems, and task-specific environments. Their performance and capacity directly affect the system's computing capabilities, response speed, and overall quality of service. The following sections describe five computing resource risks and corresponding fault tolerance strategies.

Uneven Resource Allocation

Uneven resource allocation occurs when some nodes are heavily loaded due to flawed task allocation policies, long-lived connections, or other issues, while other nodes remain underutilized. In distributed systems, nodes may also compete for limited computing resources. For example, if one node excessively consumes resources, other nodes may lack sufficient capacity, resulting in degraded performance and task delays. Common fault tolerance strategies include:

• Load balancing: Use a load balancing algorithm to evenly distribute requests or tasks across nodes. This helps fully utilize computing resources and improve system performance.

• Resource scheduling: Dynamically adjust resource allocation based on the system's load and resource utilization. When a node is overloaded, some tasks or data can be migrated to other nodes to balance resource utilization.

Insufficient Resource Capacity

Insufficient CPU or memory resources can increase task latency, slow system response, or cause task execution failures. Common fault tolerance strategies include:

• Elastic scaling: Use the elastic scaling capabilities of the cloud platform to add nodes or upgrade existing instances, increasing computing resource capacity.

• Resource scheduling: As described above.

Abnormal Task Interruption

Abnormal task interruption occurs when tasks fail to complete or are interrupted during execution, resulting in task failures. Common fault tolerance strategies include:

• Checkpoint and recovery: Periodically create checkpoints during task execution to save intermediate results and state. If a task is interrupted, it can be resumed from the last checkpoint instead of re-executing the entire task.

• Monitoring and automatic retry: Monitor task status and progress regularly. When an interruption or exception is detected, automatically retry the failed task. Use monitoring tools and task management systems to implement this strategy.

• Task splitting and parallel computing: Split the computing task into smaller subtasks and distribute them to different computing nodes for execution. Even if one node fails or is interrupted, other nodes can continue to execute the remaining subtasks, improving the fault tolerance and reliability of the task.

Task Repetition

Task repetition occurs when a computing task is executed multiple times due to duplicate operations, message duplication, or scheduling duplication. Common fault tolerance strategies include:

• Deduplication: Use unique identifiers to identify tasks and check whether a task already exists in the system. If the task already exists, return the existing result instead of executing it again.

• Idempotence: Design tasks to be idempotent so that executing a task once or multiple times produces the same result without additional side effects on system state.

Task Blocking and Accumulation

Task blocking and accumulation occur when one or more long-running or blocked tasks prevent other tasks from executing in a timely manner, causing a backlog that degrades overall performance and response time. Common fault tolerance strategies include:

• Timeout mechanism: Set a reasonable execution time limit for each task. If a task exceeds the threshold, the system aborts or cancels it and marks it as abnormal or failed. This prevents a single blocked task from delaying the entire system.

• Asynchronous execution: Process time-consuming tasks asynchronously to fully utilize computing resources, accelerate task processing, and avoid blocking the entire task execution flow.

• Priority: Assign different priorities to tasks based on their importance and urgency. Prioritize high-priority tasks to prevent them from being blocked or accumulated, ensuring system responsiveness and timely task completion.

• Task splitting and parallel computing: As described above, split the computing task into smaller subtasks and distribute them to different computing nodes for execution.

Beyond the five risks described above, common computing resource risks also include mutual resource interference, resource node crashes, dependent service exceptions, unresponsive service processes, data format exceptions, and certificate expiry. Fault tolerance strategies such as resource isolation, quota control, multi-replica redundancy, service degradation, circuit breaking, heartbeat reporting, active detection, data verification, and automatic replacement can be used to address these risks.