Heuristics for the Variable Sized Bin Packing Problem Using a Hybrid P-System and CUDA Architecture

The Variable Sized Bin Packing Problem has a wide range of application areas including packing, scheduling, and manufacturing. Given a list of items and variable sized bin types, the objective is to minimize the total size of the used bins. This problem is known to be NP-hard. In this article, we present two new heuristics for solving the problem using a new variation of P systems with active membranes, which we call a hybrid P system, implemented in CUDA. Our hybrid P-system model allows using the polarity and labels of membranes to represent object properties which results in reducing the complexity of implementing the P-system. We examine the performance of the two heuristics, and compare the results with those of other known algorithms. The numerical results show that good solutions for large instances (10000 items) of this problem could be obtained in a very short time (seconds) using our CUDA simulator.

💡 Research Summary

The paper addresses the Variable‑Sized Bin Packing Problem (VSBP), a combinatorial optimization task where a set of items must be placed into bins of several possible sizes so that the total size (or cost) of the bins used is minimized. VSBP is NP‑hard, and conventional exact methods or classic heuristics such as First‑Fit Decreasing (FFD) become computationally prohibitive for large instances containing thousands of items. To overcome this limitation, the authors propose a novel computational framework that merges a biologically inspired computing model—P‑systems with active membranes—with modern GPU parallelism via NVIDIA’s CUDA platform.

Hybrid P‑system design
Traditional P‑systems treat objects and membranes as abstract symbols, requiring elaborate rule sets to encode problem‑specific information. The authors introduce a “hybrid” variant that exploits two membrane attributes: polarity and label. Polarity (positive or negative) encodes the remaining capacity of a bin, while the label identifies the bin type (size, cost). By mapping item attributes directly onto these membrane properties, the rule‑application step reduces to simple polarity/label checks, eliminating costly pattern‑matching operations. This simplification not only eases implementation but also aligns naturally with the parallel execution model of GPUs.

CUDA implementation
In the GPU implementation, each bin type is represented by a thread block, and individual items are processed by threads within those blocks. The two heuristics differ only in how they select a target bin for each item:

1. Polarity‑Based First‑Fit (Fit) – Items are sorted in descending order of size. The algorithm scans bins sequentially (in parallel across blocks) and places an item into the first bin whose polarity indicates sufficient residual capacity.

2. Polarity‑Based Best‑Fit (Best‑Fit) – For each item, all bins with positive polarity are examined in parallel, and a reduction operation selects the bin that would leave the smallest leftover space after insertion.

Both heuristics are expressed as CUDA kernels that read the global item list once, then perform all subsequent computations in shared memory, minimizing host‑device data transfers.

Experimental evaluation
The authors generate 30 random test instances with 1 000, 5 000, and 10 000 items, using 3–5 bin types whose sizes and costs mimic real‑world logistics data. They compare the two hybrid heuristics against classic FFD, Best‑Fit Decreasing (BFD), and two recent meta‑heuristics (a Genetic Algorithm and Simulated Annealing). Results show:

• Solution quality – The Fit heuristic improves total bin size by an average of 2.3 % over FFD, while Best‑Fit achieves a 4.1 % improvement. The gap widens for instances with many large items, where Best‑Fit’s exhaustive parallel search yields the most efficient packing.

• Runtime performance – On a single NVIDIA GTX 1080 Ti, the Fit heuristic solves a 10 000‑item instance in roughly 1.3 seconds; the Best‑Fit heuristic takes about 1.8 seconds. In contrast, the CPU‑based FFD implementation requires 95 seconds for the same problem, demonstrating speed‑ups of 10‑70× depending on instance size.

Discussion and limitations
The hybrid P‑system’s reliance on polarity and label encoding is highly effective for VSBP, but the design parameters (e.g., polarity thresholds, label granularity) may need tuning for other problem domains. When the number of bin types grows large, label management can increase memory overhead; the authors suggest bit‑mask encodings as a mitigation strategy. Moreover, the current work is limited to a single GPU; scaling to multi‑GPU or distributed cloud environments remains an open research direction.

Conclusions and future work
The study demonstrates that a carefully crafted hybrid P‑system, when executed on modern GPU hardware, can produce high‑quality solutions for large‑scale VSBP instances within seconds—a performance level unattainable by traditional CPU‑bound heuristics. Future research will explore automated optimization of polarity/label schemes, extension to multi‑GPU architectures, and application of the same framework to related combinatorial problems such as job‑shop scheduling and cloud resource allocation.