This paper gives a brief overview of IoT interoperability approaches within the W3C Web of Things standard. The first part presents the core concepts of the W3C Web of Things. An outline of the family of WoT specifications is then provided. The second part focuses on the proposed WoT Profile mechanism and explains how profiles can help to address interoperability challenges.

Our ability to create systems with large amount of hardware parallelism is exceeding the average software developer's ability to effectively program them. This is a problem that plagues our industry. Since the vast majority of the world's software developers are not parallel programming experts, making it easy to write, port, and debug applications with sufficient core and vector parallelism is essential to enabling the use of multi- and many-core processor architectures. However, hardware architectures and vector ISAs are also shifting and diversifying quickly, making it difficult for a single binary to run well on all possible targets. Because of this, retargetability and dynamic compilation are of growing relevance. This paper introduces Intel®Array Building Blocks (ArBB), which is a retargetable dynamic compilation framework. This system focuses on making it easier to write and port programs so that they can harvest data and thread parallelism on both multi-core and heterogeneous many-core architectures, while staying within standard C++. ArBB interoperates with other programming models to help meet the demands we hear from customers for a solution with both greater programmer productivity and good performance. This work makes contributions in language features, compiler architecture, code transformations and optimizations. It presents performance data from the current beta release of ArBB and quantitatively shows the impact of some key analyses, enabling transformations and optimizations for a variety of benchmarks that are of interest to our customers.

Vector graphics representations of images are resolution independent. Direct use of vector images for real-time texture mapping would be desirable to avoid sampling artifacts such as blurring common with raster images. Scalable Vector Graphics (SVG) files are typical of vector graphics image representations. Such representations composite images from layers of paths and strokes defined with lines, elliptical arcs, and quadratic and cubic parametric splines.High-quality texture mapping requires both random access and anisotropic antialiasing. For vector images, these goals can be achieved by computing the distance to the closest primitives from a sample point and then mapping this distance through a soft threshold function. Representing transparency masks in this way is especially useful, since vector mattes can be used to render complex curvilinear geometry as textures on simple geometric primitives.Unfortunately, computing the exact minimum distance to the parametric curves used in vector images is difficult. Previous work has used approximations, but an accurate minimum distance is desirable in order to enable wide strokes and special effects such as embossing. In this paper, a simple algorithm is presented that can efficiently and accurately compute the minimum distance to a parametric curve when the sample point is within its radius of curvature and the curve can be segmented into monotonic regions. This technique can be used in a GPU shader to render antialiased vector images exactly as defined by SVG files.

Including multiple cores on a single chip has become the dominant mechanism for scaling processor performance. Exponential growth in the number of cores on a single processor is expected to lead in a short time to mainstream computers with hundreds of cores. Scalable implementations of parallel algorithms will be necessary in order to achieve improved single-application performance on such processors. In addition, memory access will continue to be an important limiting factor on achieving performance, and heterogeneous systems may make use of cores with varying capabilities and performance characteristics. An appropriate programming model can address scalability and can expose data locality while making it possible to migrate application code between processors with different parallel architectures and variable numbers and kinds of cores. We survey and evaluate a range of multicore processor architectures and programming models with a focus on GPUs and the Cell BE processor. These processors have a large number of cores and are available to consumers today, but the scalable programming models developed for them are also applicable to current and future multicore CPUs.

The multi-core Cell BE architecture has the potential to deliver high performance computation to many applications. However, it requires parallel programming on several levels and uses a memory model that requires explicit scheduling of memory transfers. The RapidMind development platform enables access to the power of the Cell BE by providing a simple data-parallel model of execution. It combines a dynamic compiler with a runtime streaming execution manager, and provides a single system image for computations running on multiple cores. The interface to this system is embedded inside ISO standard C++, where it can capture computations specified through an innovative metaprogrammed interface. This tutorial will introduce and demonstrate the use of the RapidMind platform on the Cell BE through a number of examples drawn from visualization and scientific computation.

The high-performance parallel processors in video accelerators, GPUs, can be used as numerical co-processors in a variety of applications. The RapidMind Development Platform is a software development system that allows the developer to use standard C++ programming to easily create high-performance and massively parallel applications that run on the GPU. Using the RapidMind platform, we compare the performance of FFT, BLAS dense matrix multiplication, and quasi-Monte Carlo option pricing benchmarks on the GPU against highly tuned CPU implementations. The advantages and limitations of GPU acceleration are discussed as well as techniques for optimizing performance.

We present a vector graphics representation suitable for real-time rendering on GPUs. Our representation can be used in place of a texture map, and renders precise antialiased edges at any magnification. A combination of texture data and procedural computation is used to evaluate an exact signed distance to a contour and its gradient. An optimized uniform grid accelerator is created using Voronoi analysis and redundancy elimination, so only the distances to a small constant number of features need be computed at every access. Contours and sharp features can be exactly reconstructed using a constant amount of computation per pixel. Our representation supports inexpensive high-quality anisotropic antialiasing as well as special effects such as outlining (with both rounded and sharp miters) and embossing.We have applied our representation to the important application of glyph rendering. Variations in glyph complexity are handled by storing different glyphs at different grid resolutions. Large blocks of glyphs can be rendered efficiently with a single indirection through an index texture.

An algebra consists of a set of objects and a set of operators that act on those objects. We treat shader programs as first-class objects and define two operators: connection and combination. Connection is functional composition: the outputs of one shader are fed into the inputs of another. Combination concatenates the input channels, output channels, and computations of two shaders. Similar operators can be used to manipulate streams and apply computational kernels expressed as shaders to streams. Connecting a shader program to a stream applies that program to all elements of the stream; combining streams concatenates the record definitions of those streams.In conjunction with an optimizing compiler, these operators can manipulate shader programs in many useful ways, including specialization, without modifying the original source code. We demonstrate these operators in Sh, a metaprogramming shading language embedded in C++.

A bidirectional reflectance distribution function (BRDF) describes how a material reflects light from its surface. To use arbitrary BRDFs in real-time rendering, a compression technique must be used to represent BRDFs using the available texture-mapping and computational capabilities of an accelerated graphics pipeline. We present a numerical technique, homomorphic factorization, that can decompose arbitrary BRDFs into products of two or more factors of lower dimensionality, each factor dependent on a different interpolated geometric parameter. Compared to an earlier factorization technique based on the singular value decomposition, this new technique generates a factorization with only positive factors (which makes it more suitable for current graphics hardware accelerators), provides control over the smoothness of the result, minimizes relative rather than absolute error, and can deal with scattered, sparse data without a separate resampling and interpolation algorithm.

Current graphics hardware can be used to generate shadows using either the shadow volume or shadow map techniques. However, the shadow volume technique requires access to a representation of the scence as a polygonal model, and handling the near plane clip correctly and efficiently is difficult; conversely, accurate shadow maps require high-precision texture map data representations, but these are not widely supported. We present a hybird of the shadow map and shadow volume approaches which does not have these difficulties and leverages high-performance polygon rendering. The scene is rendered from the point of view of the light source and a sampled depth map is recovered. Edge detection and a template-based reconstruction technique are used to generate a global shadow volume boundary surface, after which the pixels in shadow can be marked using only a one-bit stencil buffer and a single-pass rendering of the shadow volume boundary polygons. The simple form of our template-based reconstruction scheme simplifies capping the shadow volume after the near plane clip.

Monte Carlo sampling can be used to estimate solutions to global light transport and other rendering problems. However, a large number of observations may be needed to reduce the variance to acceptable levels. Rather than computing more observations within each pixel, if spatial coherence exists in image space it can be used to reduce visual error by averaging estimators in adjacent pixels. Anisotropic diffusion is a space-variant noise reduction technique that can selectively preserve texture, edges, and other details using a map of image coherence. The coherence map can be estimated from depth and normal information as well as interpixel color distance. Incremental estimation of the reduction in variance, in conjunction with statistical normalization of interpixel color distances, yields an energy-preserving algorithm that converges to a spatially nonconstant steady state.

Abstract Box splines are a multivariate extension of uniform univariate B‐splines. Direct evaluation of a box spline basis function can he difficult but they have a relatively simple Fourier transform and can therefore be evaluated with an inverse FFT. Symmetry recursive evaluation of the coefficients, and parallelization can be used to improve absolute performance. A windowing function can also he used to reduce truncation artifacts. We explore all these options in the context of a high‐performance parallel implementation. Our goal is the provision of an empirical touchstone for the inverse FFT evaluation of box spline basis functions, for eventual application to forward projection (splat‐based) volume rendering.

The theory of the multivariate polyhedral splines is applied to analytic antialiasing: a triangular simplex spline is used to represent surface intensity, while a box spline is used as a filter.Their continuous convolution is a prism spline that can be evaluated exactly via recurrence.Evaluation performance can be maximized by exploiting the properties of the prism spline and its relationship to the sampling grid.After sampling, digital signal processing can be used to evaluate exactly and efficiently the sampled result of any analytic spline filter in the span of the box spline basis used as the original analytic filter.

Maximum projection is a volume rendering technique that, for each pixel, finds the maximum intensity along a projector. For certain important classes of data, this is an approximation to summation rendering which produces superior visualizations. We show how maximum projection rendering with additional depth cues can be implemented using simple affine transformations in object space. This technique can be used together with 3D graphics libraries and standard graphics hardware, thus allowing interactive manipulations of the volume data. The algorithm presented allows for a wide range of tradeoffs between interactivity and image quality.