Bentley Rules for Optimizing Work

Question 1

What is Instruction Level Parallelism (ILP)?

Answer 1

ILP refers to the simultaneous execution of multiple instructions in a computer program to improve performance. It aims to overlap or execute instructions in parallel to enhance overall throughput.

Question 2

How is ILP achieved in a processor?

Answer 2

ILP is achieved through techniques like pipelining, superscalar architecture, and out-of-order execution. These methods allow multiple instructions to be processed simultaneously.

Question 3

Explain pipelining in the context of ILP.

Answer 3

Pipelining divides the execution of instructions into stages, allowing multiple stages to be processed concurrently. It reduces the overall time taken to complete an instruction.

Question 4

What is superscalar architecture, and how does it contribute to ILP?

Answer 4

Superscalar architecture involves multiple execution units in a processor, enabling the simultaneous execution of multiple instructions during a clock cycle, thereby increasing ILP.

Question 5

Define out-of-order execution and its role in ILP.

Answer 5

Out-of-order execution allows the processor to execute instructions not necessarily in the order specified by the program, helping maximize ILP by avoiding stalls.

Question 6

How does ILP relate to single instruction, multiple data (SIMD) processing?

Answer 6

ILP and SIMD both aim to parallelize instruction execution. SIMD processes multiple data elements using a single instruction, contributing to ILP by performing similar operations on multiple data items simultaneously.

Question 7

What challenges may limit the effectiveness of ILP in a processor?

Answer 7

Dependencies between instructions, resource contention, and limitations in the compiler’s ability to identify parallelizable code segments can hinder the effective utilization of ILP.

Question 8

In what scenarios is ILP particularly beneficial?

Answer 8

ILP is beneficial in applications with substantial parallelism, such as scientific simulations, multimedia processing, and certain numerical computations where multiple independent operations can be performed concurrently.

Question 9

How does ILP contribute to overall processor performance improvement?

Answer 9

By executing multiple instructions simultaneously, ILP increases the throughput of a processor, leading to improved performance and reduced execution time for programs.

Question 10

Name some common techniques used to enhance ILP in modern processors.

Answer 10

Techniques include speculative execution, branch prediction, data forwarding, and dynamic scheduling, all aimed at identifying and exploiting parallelism to improve ILP.

Question 11

Define Packing in the context of computer systems.

Answer 11

Packing refers to efficiently utilizing memory by grouping multiple data elements into a single storage unit, optimizing space and enhancing data access.

Question 12

Explain the significance of data packing in memory optimization.

Answer 12

Data packing reduces memory wastage by storing multiple variables or elements in a single memory location, which is crucial for efficient memory utilization and overall system performance.

Question 13

What is Encoding in computer systems?

Answer 13

Encoding involves representing data using a specific format or scheme, often to achieve compression, reduce storage requirements, or facilitate efficient data transmission.

Question 14

How does Packing contribute to memory bandwidth optimization?

Answer 14

Packing increases memory bandwidth efficiency by allowing more data to be fetched in a single memory access operation, reducing the number of accesses required for a set of data.

Question 15

Give an example of how data can be efficiently packed in a data structure.

Answer 15

In a struct or record, variables can be packed by ordering them based on size, aligning smaller data types together to minimize padding and conserve memory.

Question 16

What is the role of Padding in packing data structures?

Answer 16

Padding involves adding extra bytes to align data elements in a structure to memory boundaries. It helps maintain proper alignment, avoiding performance penalties associated with misaligned data.

Question 17

Explain the concept of Data Encoding and its applications.

Answer 17

Data encoding involves transforming data into a specific format for various purposes such as compression, encryption, or facilitating data interchange. Examples include Base64 encoding and Huffman coding.

Question 18

How does Encoding assist in data compression?

Answer 18

Encoding techniques like Huffman coding reduce the number of bits required to represent data, achieving compression by assigning shorter codes to frequently occurring symbols.

Question 19

Discuss the trade-offs associated with aggressive data packing.

Answer 19

Aggressive data packing may lead to increased complexity and potential loss of performance due to the need for unpacking operations. Balancing packing efficiency with access speed is crucial.

Question 20

In what scenarios is Encoding commonly used in computer systems?

Answer 20

Encoding is commonly used in data compression, multimedia processing, network protocols, and encryption algorithms where efficient representation and transmission of data are essential.

Question 21

Define Augmentation in the context of computer systems.

Answer 21

Augmentation refers to the process of enhancing or extending the capabilities of computer systems, often through the addition of hardware, software, or features to improve performance or functionality.

Question 22

What role does Augmentation play in system scalability?

Answer 22

Augmentation contributes to system scalability by allowing the addition of resources, such as processors, memory, or storage, to accommodate increased workloads and demands.

Question 23

Provide an example of hardware Augmentation.

Answer 23

Adding a dedicated graphics card to a computer to improve graphical processing capabilities is an example of hardware augmentation.

Question 24

How does Augmentation differ from Optimization in system improvement?

Answer 24

Augmentation involves adding new elements or features to enhance capabilities, while Optimization focuses on improving existing components for better efficiency and performance.

Question 25

Discuss the impact of Augmentation on system adaptability.

Answer 25

Augmentation enhances system adaptability by allowing the integration of new technologies, functionalities, or upgrades, ensuring the system can meet evolving requirements.

Question 26

In what ways can software Augmentation be beneficial for an application?

Answer 26

Software augmentation can introduce new features, improve user experience, fix bugs, or enhance security, contributing to the overall improvement of an application.

Question 27

Explain how Augmentation contributes to future-proofing a system.

Answer 27

By enabling the addition of newer technologies and features, augmentation helps future-proof a system, ensuring it remains relevant and capable of meeting upcoming challenges.

Question 28

Provide a scenario where Augmentation is preferred over system replacement.

Answer 28

If a server requires additional processing power, augmenting it with additional processors may be preferred over replacing the entire server, especially if other components are still viable.

Question 29

What considerations should be taken into account when planning system Augmentation?

Answer 29

Factors such as compatibility, integration, cost-effectiveness, and the potential impact on existing components should be considered when planning system augmentation.

Question 30

Discuss a real-world example where Augmentation was successfully implemented for performance improvement.

Answer 30

Upgrading a smartphone’s operating system to a newer version with enhanced features and performance is an example of successful software augmentation for performance improvement.

Question 31

What is precomputation in the context of performance engineering?

Answer 31

Precomputation involves calculating or processing certain values or results in advance, storing them, and then reusing them as needed to optimize runtime performance.

Question 32

In performance engineering, what is the purpose of using a table to store binomial coefficients?

Answer 32

The table storing binomial coefficients is precomputed to avoid redundant calculations during runtime. It enables faster retrieval of binomial coefficients, optimizing performance for algorithms that frequently require these values.

Question 33

How is Pascal’s Triangle used in algorithms and performance engineering?

Answer 33

Pascal’s Triangle is utilized for precomputing binomial coefficients. The coefficients in the triangle represent combinations, making it a valuable tool for efficient computation of these values, especially in algorithms requiring frequent binomial coefficient calculations.

Question 34

What is caching, and how does it impact performance in computer systems?

Answer 34

Caching involves storing copies of frequently accessed data in a faster, smaller memory location for quicker retrieval. It enhances performance by reducing the need to access slower, larger memory. Effective caching minimizes data access latency and optimizes overall system responsiveness.

Question 35

What is sparsity in the context of algorithms and data structures?

Answer 35

Sparsity refers to the property where a large portion of elements in a structure, such as a matrix or array, are zero or empty. Algorithms designed to exploit sparsity can optimize computations by skipping zero elements, leading to more efficient use of resources.

Question 36

What is Compressed Sparse Row (CSR), and how is it used in the context of sparse matrix representation?

Answer 36

Compressed Sparse Row (CSR) is a format for efficiently representing sparse matrices. It stores only the non-zero values and their respective column indices in three arrays: values array, column indices array, and a row pointers array. This format reduces storage space for sparse matrices and allows for efficient matrix-vector multiplication.

Question 37

What is the main advantage of using Compressed Sparse Row (CSR) format for sparse matrices?

Answer 37

The main advantage of CSR format is efficient storage, as it only stores non-zero values along with their column indices and uses a separate array for row pointers, minimizing memory requirements for sparse matrices.

Question 38

Describe the structure of a Compressed Sparse Row (CSR) representation for a sparse matrix.

Answer 38

CSR format uses three arrays: values array to store non-zero values, column indices array to store corresponding column indices, and row pointers array to indicate the start of each row in the values and column indices arrays.

Question 39

How does Compressed Sparse Row (CSR) facilitate matrix-vector multiplication for sparse matrices?

Answer 39

CSR format allows for efficient matrix-vector multiplication by iterating through non-zero elements using row pointers and performing the necessary operations, leveraging the sparsity of the matrix to optimize the computation.

Question 40

What is the purpose of the row pointers array in Compressed Sparse Row (CSR) format?

Answer 40

The row pointers array in CSR format indicates the starting index in the values and column indices arrays for each row. It enables quick access to non-zero elements of each row during matrix operations.

Question 41

In what scenarios is Compressed Sparse Row (CSR) particularly beneficial compared to other sparse matrix representations?

Answer 41

CSR is beneficial when matrices are large and sparse, as it optimizes storage by only storing non-zero values and their indices. It is efficient for operations like matrix-vector multiplication in sparse linear algebra applications.

Question 42

In what scenarios does dense representation take less space compared to sparse representations like Compressed Sparse Row (CSR)?

Answer 42

Dense representation takes less space when the majority of matrix elements are non-zero, as sparse representations like CSR are designed to efficiently store matrices with a significant number of zero values.

Question 43

What are constant folding and propagation in the context of compiler optimization?

Answer 43

Constant folding involves evaluating constant expressions at compile-time, replacing them with their computed values. Constant propagation is the process of substituting known constant values into expressions during compilation.

Question 44

Explain “constant propagation” in the context of compiler optimization.

Answer 44

Constant propagation is a compiler optimization technique that involves replacing variables with their constant values when the values are known at compile-time. This helps in eliminating redundant computations and improving the efficiency of the compiled code.

Question 45

Define “common subexpression elimination” in compiler optimization.

Answer 45

Common subexpression elimination is a compiler optimization technique that identifies and eliminates redundant computations by recognizing expressions that are computed multiple times within a program. It aims to reduce unnecessary calculations and improve the efficiency of the compiled code.

Question 46

Provide an example of common subexpression elimination in code.

Answer 46

Consider the expression a = b + c * d; occurring multiple times in a program. Common subexpression elimination would recognize this repetition and calculate c * d only once, storing the result in a temporary variable to be reused in subsequent occurrences of the expression.

Question 47

Explain the concept of algebraic identities and how they can be applied in code optimization.

Answer 47

Algebraic identities are mathematical equivalences. In code optimization, algebraic identities can be leveraged to simplify expressions and reduce redundancy. For example, using the distributive property (a * (b + c) = a * b + a * c) can lead to more efficient code by eliminating unnecessary calculations.

Question 48

What are floating-point overflow issues, and how can they impact numerical computations?

Answer 48

Floating-point overflow occurs when the result of a computation exceeds the maximum representable value for a given data type. This can lead to inaccuracies and unexpected behavior in numerical computations. It’s crucial to handle overflow situations carefully to ensure the reliability of the calculations.

Question 49

What is fast path optimization in the context of performance engineering?

Answer 49

Fast path optimization involves identifying and optimizing the most common or critical execution paths in a program to achieve higher performance. By focusing on the frequently executed code paths, developers can make targeted improvements to enhance overall efficiency.

Question 50

What is short-circuiting in the context of programming?

Answer 50

Short-circuiting is a behavior in programming languages where the evaluation of a logical expression stops as soon as the final outcome can be determined. If the result can be decided based on the evaluation of the initial part of the expression, the remaining part is not executed, improving efficiency.

Question 51

Provide an example of short-circuiting in a programming context.

Answer 51

In the logical AND operation (&&), if the first operand is false, the second operand is not evaluated. For instance, in the expression (A && B), if A is false, the system doesn’t check B, saving computational resources.

Question 52

Define Performance Engineering in the context of computing.

Answer 52

Performance Engineering involves optimizing the execution speed and resource utilization of computer programs. It includes techniques such as parallelization, vectorization, and algorithmic improvements to enhance overall system performance.

Question 53

Why is ordering tests important in performance engineering?

Answer 53

Ordering tests is crucial to efficiently utilize time in performance engineering. Running more time-consuming tests early allows for parallel execution, minimizing overall testing time.

Question 54

What is a full adder?

Answer 54

A full adder is a digital circuit that performs addition on three binary digits. It takes two binary inputs and a carry input, producing a sum output and a carry output.

Question 55

Can you provide an example of a full adder?

Answer 55

Sure! Let’s say we want to add binary numbers 101 and 011. The full adder would process each bit along with a carry, producing a sum and carry for each bit. For the rightmost bit: 1 (A) + 1 (B) + 0 (carry) = 10 (sum) with a carry of 1.

Question 56

Why is parallelizing outer loops often better than inner loops for performance optimization?

Answer 56

Parallelizing outer loops is generally more effective because it reduces scheduling overhead. Outer loops represent a higher-level structure in the code, and parallelizing them tends to lead to better performance gains compared to inner loops.

Question 57

What is hoisting in the context of performance optimization?

Answer 57

Hoisting is a compiler optimization technique that involves moving a computation or operation outside a loop or block, reducing redundant calculations and improving efficiency.

Question 58

Provide an example of hoisting in the context of performance optimization

Answer 58

In a loop, if there’s a constant calculation that doesn’t change in each iteration, hoisting involves moving that calculation outside the loop to avoid redundant computation. For example, moving a loop-invariant multiplication outside the loop.

Question 59

Provide an example of hoisting in the context of performance optimization.

Answer 59

In a loop, if there’s a constant calculation that doesn’t change in each iteration, hoisting involves moving that calculation outside the loop to avoid redundant computation. For example, moving a loop-invariant multiplication outside the loop.

Question 60

What is loop unrolling in the context of performance optimization?

Answer 60

Loop unrolling is a technique where multiple iterations of a loop are combined or unfolded into a single iteration. This aims to reduce loop control overhead and increase instruction-level parallelism.

Question 61

What are sentinels in the context of algorithm design?

Answer 61

Sentinels are special values used in data structures or arrays to indicate the end of a particular sequence or data set. They help simplify boundary checks and termination conditions in algorithms.

Question 62

How are Sentinels employed in array-based data structures to signify the end of elements?

Answer 62

In array-based data structures, a Sentinel value is placed at the end of the array to indicate where the valid elements conclude. It helps algorithms determine when to stop processing.

Question 63

What role do Sentinels play in searching algorithms, and how do they contribute to code simplicity?

Answer 63

In searching algorithms, Sentinels are used to avoid explicit bounds checking. Placing a Sentinel value ensures that the search loop stops naturally when the end of the data is reached, simplifying code logic.

Question 64

How can Sentinels enhance the efficiency of algorithms that involve boundary conditions or termination checks?

Answer 64

Sentinels simplify boundary conditions and termination checks by providing a known, easily recognizable value. This clarity in marking endpoints contributes to more readable and maintainable code.

Question 65

Provide an example of how Sentinels can be utilized in a context like searching for an element in an array.

Answer 65

In searching, a Sentinel might be added at the end of an array. When searching for an element, the loop can iterate until the Sentinel is encountered, eliminating the need for a separate length check.

Question 66

What is “Loop Unrolling” in the context of programming and optimization?

Answer 66

“Loop Unrolling” is an optimization technique where iterations of a loop are unfolded or expanded, resulting in a larger body of code with multiple statements executed in each iteration. This aims to reduce loop overhead and enhance performance.

Question 67

How does Loop Unrolling contribute to improving the performance of a loop?

Answer 67

Loop Unrolling can improve performance by reducing the overhead of loop control structures. With multiple loop iterations combined into one, the number of loop control instructions decreases, leading to more efficient use of hardware resources.

Question 68

What are some potential benefits of Loop Unrolling in terms of instruction pipelining and parallelism?

Answer 68

Loop Unrolling can expose additional opportunities for instruction pipelining and parallelism. By having more instructions within a loop, the pipeline can be filled more effectively, and parallel execution of instructions becomes feasible.

Question 69

Are there any drawbacks or considerations when applying Loop Unrolling to a loop?

Answer 69

Loop Unrolling can result in increased code size, potentially leading to larger memory footprint. Additionally, the effectiveness depends on the target architecture, and excessive unrolling may not always yield performance gains.

Question 70

Can Loop Unrolling be done manually by programmers, or is it typically handled by compilers?

Answer 70

Both manual and automatic (compiler-driven) approaches are possible. Programmers can manually unroll loops by duplicating code, and some compilers offer optimization flags or settings to automatically perform loop unrolling during compilation.

Question 71

What is “Partial Loop Unrolling” in the context of programming optimization?

Answer 71

“Partial Loop Unrolling” is an optimization technique where only a subset of loop iterations is unfolded or expanded, instead of unrolling the entire loop. This approach aims to balance the benefits of reduced loop overhead and increased instruction parallelism with the drawbacks of larger code size.

Question 72

How does Partial Loop Unrolling differ from Full Loop Unrolling, and what are the advantages of partial unrolling?

Answer 72

In Partial Loop Unrolling, only a portion of the loop iterations is expanded, striking a balance between code size and performance. This helps in minimizing the potential increase in code size while still benefiting from reduced loop overhead and improved instruction parallelism.

Question 73

What factors influence the decision to use Partial Loop Unrolling?

Answer 73

The decision to use Partial Loop Unrolling depends on trade-offs between code size, performance gains, and the characteristics of the target architecture. It may be preferred when full unrolling leads to excessive code size increase or when specific loop patterns benefit more from partial expansion.

Question 74

Can programmers manually control the degree of partial unrolling, or is it typically handled by compilers?

Answer 74

Both manual and compiler-driven approaches are possible. Programmers can manually decide how many loop iterations to unroll, or compilers may provide optimization flags or settings to control the degree of partial loop unrolling during compilation.

Question 75

What is “Loop Fusion” in the context of programming optimization?

Answer 75

“Loop Fusion” is an optimization technique where multiple consecutive loops are combined or fused into a single loop. This aims to improve cache locality, reduce loop overhead, and enhance overall program performance by minimizing redundant computations.

Question 76

How does Loop Fusion contribute to improved cache locality and why is it important?

Answer 76

Loop Fusion helps improve cache locality by reducing the number of cache misses. Combining loops reduces the data access patterns, allowing the processor to reuse data already present in the cache. This can lead to better utilization of cache memory and improved program performance.

Question 77

What are the potential advantages of Loop Fusion in terms of reducing loop overhead?

Answer 77

Loop Fusion can reduce loop overhead by eliminating redundant loop structures, such as loop initialization and termination conditions. This consolidation of loop-related operations can result in more efficient execution, contributing to overall performance improvements.

Question 78

Are there any considerations or trade-offs that programmers need to be aware of when applying Loop Fusion?

Answer 78

Programmers should consider the dependencies and interactions between the loops being fused. Dependencies might limit the degree of fusion or introduce complexities. Additionally, increased loop fusion may impact code readability, so balancing optimization gains with code maintainability is essential.

Question 79

What does “Eliminating Wasted Iterations” refer to in the context of loop optimization?

Answer 79

“Eliminating Wasted Iterations” involves optimizing loops by avoiding unnecessary iterations or computations. This can be achieved by introducing early exit conditions or restructuring the loop logic to skip iterations when certain conditions are met, improving overall program efficiency.

Question 80

How can early exit conditions contribute to eliminating wasted iterations in a loop?

Answer 80

Early exit conditions allow a loop to terminate before completing all iterations if certain conditions are met. By strategically placing exit checks, programmers can skip unnecessary iterations, reducing computational overhead and improving the efficiency of the loop.

Question 81

What are some common techniques for restructuring loops to eliminate wasted iterations?

Answer 81

Techniques include loop unrolling, loop fusion, and loop reordering. Loop unrolling reduces the number of iterations by processing multiple loop elements in each iteration. Loop fusion combines multiple loops into one, eliminating redundant iterations. Loop reordering changes the order of loop operations to improve data access patterns and reduce wasted iterations.

Question 82

Why is eliminating wasted iterations important for optimizing loop performance?

Answer 82

Eliminating wasted iterations is crucial for improving program efficiency and reducing computational overhead. By minimizing unnecessary computations, programs can run faster and consume fewer resources, contributing to overall performance optimization.

Question 83

Can you provide an example of how matrix transposition can be implemented in code?

Answer 83

void transposeMatrix(int matrix[][COL], int transposed[][ROW]) {
for (int i = 0; i < ROW; i++) {
for (int j = 0; j < COL; j++) {
transposed[j][i] = matrix[i][j];
}
}
}

Question 84

How does matrix transposition contribute to improving cache locality in algorithms?

Answer 84

Matrix transposition can improve cache locality by transforming data access patterns. When algorithms operate on transposed matrices, they exhibit better spatial locality, reducing cache misses and enhancing data retrieval efficiency. This can lead to performance improvements, especially in computations involving large matrices.

Question 85

In what scenarios is matrix transposition commonly employed for performance optimization?

Answer 85

Matrix transposition is often employed in numerical computations, linear algebra algorithms, and data processing tasks where optimizing data access patterns is crucial. It is commonly used in applications such as matrix multiplication, convolution operations, and various scientific computations to enhance overall performance.

Question 86

What is tail recursion, and how does tail recursion elimination contribute to optimizing recursive functions?

Answer 86

Tail recursion occurs when a recursive function’s last operation is a recursive call. Tail recursion elimination is an optimization technique where the compiler transforms tail-recursive functions into iterative ones. This helps prevent stack overflow issues and improves the efficiency of recursive algorithms.

Question 87

Can you provide an example of a tail-recursive function and its transformation after tail recursion elimination?

Answer 87

Certainly! Consider the factorial function in a tail-recursive form and its transformation:
// Tail-recursive factorial function
function tailRecursiveFactorial(n, accumulator = 1) {
if (n === 0) {
return accumulator;
} else {
return tailRecursiveFactorial(n - 1, n * accumulator);
}
}
After tail recursion elimination:
// Iterative factorial function (tail-recursive elimination)
function iterativeFactorial(n) {
let result = 1;
for (let i = 1; i <= n; i++) {
result *= i;
}
return result;
}

Question 88

What benefits does tail recursion elimination offer in terms of memory usage and efficiency?

Answer 88

Tail recursion elimination can significantly reduce the memory footprint of recursive functions. By transforming them into iterative equivalents, it avoids the accumulation of stack frames, preventing stack overflow issues. This optimization improves both memory usage and execution speed, making recursive algorithms more efficient.

Question 89

When should tail recursion elimination be applied, and are there programming languages that automatically perform this optimization?

Answer 89

Tail recursion elimination is beneficial when dealing with tail-recursive functions, especially in languages that lack proper tail-call optimization. While some programming languages, like Scheme or Haskell, perform automatic tail-call optimization, others, like JavaScript, may not. In such cases, manual application of tail recursion elimination can enhance the performance of recursive algorithms.

Question 90

What is coarsening recursion, and how does it contribute to optimizing recursive functions?

Answer 90

Coarsening recursion is an optimization technique that involves adjusting the granularity of recursive calls. Instead of making fine-grained recursive calls, coarsening combines multiple recursive steps into a single, coarser step. This helps reduce the overhead of recursive calls and enhances the overall efficiency of recursive algorithms.

Question 91

Can you provide an example illustrating coarsening recursion in a recursive algorithm?

Answer 91

Certainly! Let’s consider the classic example of the Fibonacci sequence. The naive recursive approach can be optimized using coarsening recursion
// Naive recursive Fibonacci function
function fibonacciNaive(n) {
if (n <= 1) {
return n;
} else {
return fibonacciNaive(n - 1) + fibonacciNaive(n - 2);
}
}
Coarsening recursion optimization:
// Coarsened recursive Fibonacci function
function fibonacciCoarsened(n, memo = {}) {
if (n <= 1) {
return n;
} else if (memo[n]) {
return memo[n];
} else {
memo[n] = fibonacciCoarsened(n - 1, memo) + fibonacciCoarsened(n - 2, memo);
return memo[n];
}
}
In the coarsened version, memoization is used to store intermediate results, preventing redundant recursive calls and improving performance.

Question 92

What advantages does coarsening recursion offer in terms of performance and resource utilization?

Answer 92

Coarsening recursion provides performance benefits by reducing the number of recursive calls. It minimizes the overhead associated with fine-grained recursion, resulting in faster execution. Additionally, coarsening can lead to better resource utilization, as it avoids excessive function call stack depth, reducing the risk of stack overflow.

Question 93

Are there any considerations or trade-offs to be aware of when applying coarsening recursion in optimization?

Answer 93

While coarsening recursion can improve performance, it may introduce additional memory usage due to memoization or caching of intermediate results. Care should be taken to strike a balance between reduced recursion overhead and potential memory overhead. The choice of granularity for coarsening depends on the specific characteristics of the recursive algorithm and the available resources.