Parallel Template Library (PTL) for .NET and Java Overview (Video)

We’ve been working on a new video series to showcase our Parallel Template Library (PTL), which is a generic and parallel programming library for .NET and Java. Our first video gives an overview of PTL’s strengths and innovations:

Parallel Template Library (PTL) simplifies parallel performance for .NET and Java developers. We developed PTL for software developers who don’t have the time or resources to become parallel programming experts but who still want to take advantage of parallelism and multicore processors to improve the performance of their existing applications. We understand that not everyone will be as passionate about parallel programming as we are, but we strongly believe that it should be used more often to take advantage of modern hardware.

Often, expert software developers focus only on obtaining more performance, and parallel programming solutions are still too complex for the majority of developers. PTL achieves high performance parallelism while still being generic and easy to use.

PTL’s parallel algorithms scale dynamically with the number of available processor cores to achieve maximum performance for the current system. PTL is also a generic library, so its functions can be used with any data type. However, it’s important to note that PTL’s design doesn’t sacrifice performance to achieve this flexibility.

PTL’s interfaces are no different than other standard libraries, so it’s easy for developers to learn and use. Developers can focus on the business logic of their applications while PTL handles the complexities of parallelism internally. The sequential and parallel versions for the majority of PTL’s methods have the exact same usage and parameters; only their method names differ because parallel methods are prefixed with a “P” (e.g. Sort vs. PSort).

PTL’s functionality is divided into six components. The Tasks component provides parallel for loop and invoke methods to simply the work of writing concurrent and asynchronous code. The majority of PTL’s parallel functionality resides in its Array and Iterator Algorithms components, which contain parallel versions of many common algorithms that operate on ranges of arrays or iterators. PTL algorithms can be used with custom containers that you design or with PTL’s Containers components. The Containers component provides containers such as lists and maps that have been optimized for parallelism. PTL also offers Persistent Containers that can be used as a data repository for your application. Finally, the Matrices component offers parallel versions of common matrix operations.

PTL’s components are completely decoupled, which makes it very easy to add new components that work with existing ones. Developers can design custom components that work with PTL, such as custom containers that work with PTL’s parallel algorithms, and we also plan to add more components based on customer needs.

PTL offers many innovations that make it “better by design.” First, PTL’s superior memory management scheme is more complex than the traditional method used to make containers resizable, where the current container is destroyed and a new, larger container is created. PTL’s method uses memory much more efficiently due to an innovative architecture on which all of PTL’s containers are based. Even though PTL’s container architecture is more complex, it still performs random access of elements just as fast as traditional .NET and Java containers. PTL containers can grow efficiently in small increments to very large sizes, so they’re especially useful for large data sets. PTL’s memory management scheme will be discussed in more detail in a separate video and blog post.

PTL also provides faster access to data through its efficient implementation of iterators. PTL containers implement more types of iterators than are offered in .NET and Java – such as input, output, forward and bidirectional iterators – which are useful for different algorithms. What really sets PTL apart is that most PTL containers implement random-access iterators, which are very useful for parallel algorithms. Random-access iterators have the ability to jump from one position to another very quickly using a simple addition, so they’re useful to partition work between cores to obtain good parallel performance.

PTL also has innovative load balancing techniques which guarantee that all of the available hardware resources are utilized to their full potential. Our load balancing algorithms are designed with heterogeneous computing devices in mind and adapt to different computing devices with different speeds.

If you’re ready to take advantage of parallelism and improve your application’s performance, you can watch our first PTL video, download free trials of all PTL components and stay tuned for more blog posts with new PTL videos. In the blog or video comments, please let us know what other components or functions from PTL you would like to see demos or tutorials of soon.

LinkedInGoogle+TwitterFacebookGoogle GmailShare

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>