minversion = "9.0"
addopts = [
  "--strict-config",
  "--strict-markers",
  "--ignore=docs_src",
]
strict_xfail = true
filterwarnings = [
    "error",
]
timeout = "20"

[tool.coverage.run]
parallel = true
data_file = "coverage/.coverage"
source = [
    "docs_src",
    "tests",
    "fastapi"
]
relative_files = true
context = '${CONTEXT}'
omit = [
    "tests/benchmarks/*",

## Recap { #recap }

You can use multiple worker processes with the `--workers` CLI option with the `fastapi` or `uvicorn` commands to take advantage of **multi-core CPUs**, to run **multiple processes in parallel**.

You could use these tools and ideas if you are setting up **your own deployment system** while taking care of the other deployment concepts yourself.

  annotations: {{- toYaml .Values.additionalAnnotations | nindent 4 }}
  {{- end }}
spec:
  updateStrategy:
    type: {{ .Values.statefulSetUpdate.updateStrategy }}
  podManagementPolicy: "Parallel"
  serviceName: {{ template "minio.fullname" . }}-svc
  replicas: {{ $replicas }}
  selector:
    matchLabels:
      app: {{ template "minio.name" . }}
      release: {{ .Release.Name }}
  template:
    metadata:

            final long elapsed = System.currentTimeMillis() - startTime;

            assertNotNull(results);
            // Verify it doesn't take too long (parallel execution should help)
            assertTrue("Search took too long: " + elapsed + "ms", elapsed < 5000);
        }
    }

    /**
     * Searcher that throws an exception during search.
     */

Since HTTP requests frequently happen in parallel, connection pooling must be thread-safe.

These are the primary classes involved with establishing, sharing, and terminating connections:

        NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build();
    undirectedNetwork.addNode(N0);
    undirectedNetwork.addEdge(N1, N2, E12);
    undirectedNetwork.addEdge(N2, N1, E12_A); // adds parallel edge, won't be in Graph edges
    undirectedNetwork.addEdge(N1, N3, E13);
    undirectedNetwork.addEdge(N4, N4, E44);
    containsExactlySanityCheck(
        undirectedNetwork.asGraph().edges(),

        NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build();
    undirectedNetwork.addNode(N0);
    undirectedNetwork.addEdge(N1, N2, E12);
    undirectedNetwork.addEdge(N2, N1, E12_A); // adds parallel edge, won't be in Graph edges
    undirectedNetwork.addEdge(N1, N3, E13);
    undirectedNetwork.addEdge(N4, N4, E44);
    containsExactlySanityCheck(
        undirectedNetwork.asGraph().edges(),

import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

/**
 * Benchmarks the overhead of constructing {@link Aggregator}s in many
 * parallel threads. Machines with different numbers of cores will see
 * wildly different results running this from running this with more
 * cores seeing more benefits from preallocation.
 */
@Fork(2)
@Warmup(iterations = 10)

      public boolean isDirected() {
        return AbstractBaseGraph.this.isDirected();
      }

      @Override
      public boolean allowsParallelEdges() {
        return false; // Graph doesn't allow parallel edges
      }

      @Override
      public boolean allowsSelfLoops() {
        return AbstractBaseGraph.this.allowsSelfLoops();
      }

      @Override
      public ElementOrder<N> nodeOrder() {

    }

    /**
     * @return True if the <code>Mojo</code> is thread-safe and can be run safely in parallel
     * @since 3.0-beta-2
     */
    public boolean isThreadSafe() {
        return threadSafe;
    }

    /**
     * @param threadSafe indicates that the mojo is thread-safe and can be run safely in parallel
     * @since 3.0-beta-2
     */
    public void setThreadSafe(boolean threadSafe) {