Plurality’s general-purpose accelerator includes 16-256 cores that scale linearly, regardless of your processing requirements and regardless of the number of cores. The company’s hardware-based Synchronizer/Scheduler ensures low-latency, high-throughput access to, and management of, the cores, including load balancing of the tasks among the cores. Plurality’s task-oriented programming model enables developers to recompile an existing program written for a single processor and to intuitively code new programs for manycore processing. Finally, Plurality’s patent-pending shared memory technology overcomes the issue of efficient memory access by enabling each core to have direct, equidistant access to memory.

Multiprocessor design initiatives are recognized in this emerging worldwide market, despite scores of unresolved questions and debate. The challenges multiprocessor design companies face, are in both hardware and software.

Conventional ideas and once acceptable principles no longer work. New methodologies must be employed to deliver new solutions. The multicore revolution promises to increase processing power in accordance with the number of cores. Current architectures, however, while combining several cores, suffer greatly from bottlenecks, poor parallelism, and oftentimes increasing the number of cores, results in slowdown rather than speedup. Further, system programmers are forced to tediously manage and administer the parallelism in complex multicore machines on their own. An innovative, integrated hardware and software approach is crucial in overcoming this challenge.

To develop and deploy industry-standard solutions that accelerate time-to-market, Plurality's researchers realized that the key to building efficient multicore systems was in the development of a hardware mechanism capable of automatically managing the parallel work. This included synchronization, scheduling, and a load balancing solution, all at a very high rate with significantly small latencies.

This approach became the key for converting parallel processing into a practical technology, enabling a feasible and flexible method of writing various software applications at very fine granularity, and running them efficiently. This task had to be accomplished without self-management, causing significant system slowdown from software overhead, limitations, constraints, bottlenecks, and serialization effects.