Shared Connection Pool for Parallel Database Access

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

In distributed database environments, existing connection pooling mechanisms face challenges in efficiently managing end-to-end connections for parallel processing applications, leading to suboptimal resource utilization and increased latency due to the limited number of pool connections and concurrent access demands.

Innovation Solution

A shared connection pool system is implemented, where each pool connection is dynamically allocated among multiple threads, with a pool manager managing physical and virtual connections to ensure efficient use of resources by reallocating connections and utilizing a wait-and-signal mechanism for threads waiting for access, thereby optimizing the use of limited pool connections.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Quantity of substance

If a connection pool is configured with a limited number of pool connections to manage resources, then resource utilization is constrained, but connection availability increases for parallel processing threads

Engineering Contradiction:
Improvenumber of pool connectionsVSAvoidthroughput performance
Core Design Contradiction:
Quantity of substanceVSProductivity

Solution Approach 1:

The system dynamically allocates and deallocates connections from the pool to threads based on real-time demand. The connection pool manager monitors connection availability and thread requirements, allocating connections dynamically rather than using static allocation. This allows the system to optimize resource utilization while maintaining high throughput by adjusting connection distribution adaptively.

Inventive Principle:
Principle #15Dynamics

2Productivity

If multiple threads concurrently access the connection pool, then parallel processing capability increases, but connection contention and latency increase

Engineering Contradiction:
Improveparallel processing capabilityVSAvoidconnection access latency
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

The connection pool manager acts as an intermediary between threads and the connection pool. It receives connection requests from multiple threads, manages the allocation of connections from the pool, and coordinates access to minimize contention. This mediator layer abstracts the complexity of concurrent access and implements efficient allocation strategies that reduce latency while maintaining high parallel processing capability.

Inventive Principle:
Principle #24Intermediary (Mediator)

3Productivity

If the connection pool size is increased to handle more concurrent requests, then throughput performance improves, but resource consumption increases

Engineering Contradiction:
Improvethroughput performanceVSAvoidresource consumption
Core Design Contradiction:
ProductivityVSQuantity of substance

Solution Approach 1:

Each connection in the pool is designed to be universal and can be allocated to any thread that requires it, rather than being dedicated to a specific thread. This multi-functionality allows a smaller number of connections to serve multiple threads through dynamic allocation, achieving high throughput performance without proportionally increasing resource consumption. The same connection can be reused by different threads at different times.

Inventive Principle:
Principle #6Universality (Multi-functionality)

Data Source

PatentUS11947534B2Connection pools for parallel processing applications accessing distributed databases
Publication Date: 2024.04.02 ORACLE INT CORP
  • US11947534B2 patent drawing
  • US11947534B2 patent drawing
  • US11947534B2 patent drawing

AI summary

A server system provided according to an aspect of the present disclosure provides a shared connection pool to parallel execution entities accessing database instances of a distributed database when processing requests. A shared connection pool implies that each pool connection of the connection pool may be used for serving different execution entities requiring access to different database instances. In an embodiment, the database instances correspond to shards together implementing a distributed database, and the parallel execution entities correspond to threads.