LiDAR Point Cloud segmentation is a key input to downstream tasks such as object recognition and classification, obstacle avoidance, and even 3D reconstruction. Akey challenge in the segmentation of large city-scale datasets is uneven distribution of points to specific classes and significant class imbalances. As highly detailed point cloud datasets of urban environments become available, neural networks have shown significant performance in recognizing large well-defined objects. However, data is fed into these networks in chunks and the scheme by which data is presented for training and evaluation can have a significant impact on performance. In this work, we establish a method analogous to gradients in image processing to segment the ground in point clouds, achieving an accuracy of 91.4% on the Sensaturban dataset. By isolating the ground, we reduce the quantity of classes that need to be segmented from structures in urban LiDAR and improve data partitioning schemes when combined with random/grid down-sampling techniques for neural network inputs.

Current mission planning simulations are typically carefully designed around a tradeoff between tight integration with accurate geospatial data or meeting real-time demands. Our proposed system is designed to achieve both. Deriving from work on cloud geospatial stores and mission planning systems, we are developing a platform for consuming new data, building it into models accessible from a real-time simulation server, and constructing machine learning systems over this data. This combination of large datasets with continuous pipelines feeding a real-time simulation forces us to bring together innovations on both the cloud infrastructure and user interface level.

In an emergency, response services require guaranteed availability regardless of failures in data transport layer and cloud service providers. In the work-in-progress reported here, we discuss three projects that have requirements that stress web infrastructure in preparing for and responding to emergencies. Our goal is to highlight the tradeoffs in costs and benefits of web services in each case, and to provide an indication of our approaches in addressing these issues.

Do students recognize the relationship between self-sufficient problem solving and exam performance? We explore this question based on log data and survey results collected over 3 semesters from 465 students who were split into cohorts based on final exam performance. Specifically, we consider three metrics: time on task, question difficulty, and self-efficacy ratings.

Educational research has established that learning can be defined as an enduring change in behaviour, which results from practice or other forms of experience. In introductory programming courses, proficiency is typically approximated through relatively small but frequent assignments and tests. Scaling these assessments to track significant behavioural change is challenging due to the subtle and complex metrics that must be collected from large student populations. Based on a four-semester study, we present an analysis of learning tool interaction data collected from 514 students and 38,796 solutions to practice programming exercises. We first evaluate the effectiveness of measuring workflow patterns to detect students at-risk of failure within the first three weeks of the semester. Our early predictor analysis accurately detects 81% of the students who struggle throughout the course. However, our early predictor also captures transient struggling, as 43% of the students who ultimately did well in the course were classified as at-risk. In order to better differentiate sustained versus transient struggling, we further propose a trajectory metric which measures changes in programming behaviour. The trajectory metric detects 70% of the students who exhibit sustained struggling, and mis-classifies only 11% of students who go on to succeed in the course. Overall, our results show how detecting changes in programming behaviour can help us differentiate between learning and struggling in CS1.

Recent research suggests that one-third of the students enrolled in CS1 courses typically end up failing. Several studies have demonstrated how learning tools can assist struggling students. This work presents the evolution of a practice tool co-designed with student input. BitFit was developed to (1) provide students with an environment to practice weekly material and receive support when needed; and (2) collect student usage data as students progress through programming exercises. Our analysis of 652 students over three semesters highlights a number of predictors for success. Our findings support recent studies that suggest that at-risk students can be identified as early as two weeks into the semester; this group accounted for almost 30% of the students who failed the course in our study. Our results also reveal that interaction patterns with BitFit, in particular with hint features requested by students, allow the identification of another 52% of students who eventually fail. Throughout the semester, students who failed the course used hint features four times as often as top students, while only attempting to compile code one-third as often. The combination of early indicators and interaction patterns identify 81% of students who failed the course during our study.

Recent research suggests that one-third of the students enrolled in CS1 courses typically end up failing [4]. Several studies have demonstrated how learning tools can assist struggling students [3]. We present an online, open-source, practice programming tool. BitFit was developed to (1) provide students with an environment to practice weekly material and receive support when needed; and (2) collect student usage data as students progress through programming exercises [2]. We present the core features of BitFit, as well as our qualitative and quantitative analysis of 652 students over three semesters of our CS1 course.

We describe the Ignite Distributed Collaborative Scientific Visualization System (IDCVS), a system which permits real-time interaction and visual collaboration around large data sets, with an initial emphasis on scientific data. The IDCVS offers such a collaborative environment, with real-time interaction on any device between users separated across the wide area. It provides seamless interaction and immediate updates even under heavy load and when users are widely separated: the design goal was to fetch a data set consisting of 30,000 points from a server and render it within 150ms, for a user anywhere in the world, and reflect changes made by a user in one location to all other users within a bound provided by network latency. The system was demonstrated successfully on a significant worldwide air pollution data set, with values on 10, 25, 50, and 100km worldwide grids, monthly over an 18-year period. It was demonstrated on a wide variety of clients, including laptop, tablet, and smartphone.

Distributed platforms are now a de facto standard in modern software and application development. Although the ACM/IEEE Curriculum 2013 introduces Parallel and Distributed Computing as a first class knowledge area for the first time, the right level of abstraction to teach these concepts is still an important question that needs to be explored. This work presents our findings in teaching cloud computing by exposing upper-level students to testbeds in use by the distributed systems research community. The possibility of giving students practical and relevant experience was explored in the context of new course assignment objectives. Furthermore, students were able to significantly contribute to a pilot class project with medium-scale computation based on satellite data. However, the software engineering challenges in these environments proved to be daunting. In particular, these challenges were exacerbated by a lack of debugging support relative to the environments students were more familiar with---requiring development practices that out-stripped typical course experiences. Our proposed set of experiments and project provide a basis for an evaluation of the trade-offs of teaching cloud and distributed systems on the wild side. We hope that these findings provide insight into some of the possibilities to consider when preparing the next generation of computer scientists to engage with software practices and paradigms that are already fundamental in today's highly distributed systems.

With the advent of Internet of Things, we are facing another wave of malware attacks, that encompass intelligent embedded devices. Because of the limited energy resources, running a complete malware detector on these devices is quite challenging. There is a need to devise new techniques to detect malware on these devices. Malware detection is one of the services that can be provided as an in-cloud service. This paper reviews current such systems, discusses there pros and cons, and recommends an improved in-cloud malware analysis and detection system. We introduce a new three layered hybrid system with a lightweight antimalware engine. These features can provide faster malware detection response time, shield the client from malware and reduce the bandwidth between the client and the cloud, compared to other such systems. The paper serves as a motivation for improving the current and developing new techniques for in-cloud malware analysis and detection system.

Despite defensive advances, malicious software (malware) remains an ever present cyber-security threat. Cloud environments are far from malware immune, in that: i) they innately support the execution of remotely supplied code, and ii) escaping their virtual machine (VM) confines has proven relatively easy to achieve in practice. The growing interest in clouds by industries and governments is also creating a core need to be able to formally address cloud security and privacy issues. VM introspection provides one of the core cyber-security tools for analyzing the run-time behaviors of code. Traditionally, introspection approaches have required close integration with the underlying hypervisors and substantial re-engineering when OS updates and patches are applied. Such heavy-weight introspection techniques, therefore, are too invasive to fit well within modern commercial clouds. Instead, lighter-weight introspection techniques are required that provide the same levels of within-VM observability but without the tight hypervisor and OS patch-level integration. This work introduces Maitland as a prototype proof-of-concept implementation a lighter-weight introspection tool, which exploits paravirtualization to meet these end-goals. The work assesses Maitland's performance, highlights its use to perform packer-independent malware detection, and assesses whether, with further optimizations, Maitland could provide a viable approach for introspection in commercial clouds.

This paper focuses on the problem of resource consolidation management within cloud computing environments and extends our previous IMPROMPTU model which demonstrated the viability of distributed Multiple Criteria Decision Analysis (MCDA) to provide a resource consolidation management that simultaneously achieves lower numbers of reconfiguration events and fewer service level agreement (SLA) violations as compared to other approaches. A core limitation of our previous work was that it only assessed the PROMETHEE II outranking-based MCDA method, leaving open the question of whether better outranking schemes exist and, more generally, what denotes the properties of good outranking approaches for this problem domain. This work addresses these deficiencies through extending the IMPROMPTU model to directly compare PROMETHEE II with ELECRE III and PAMSSEM II, two other well-known outranking-based MCDA schemes. An in-depth analysis of the generated simulation results are then used to highlight the core trade-offs between each of these MCDA approaches.

Users of parallel patterns need to carefully consider many subtle aspects of software design. In particular, implicit relationships with hardware realities coupled with aggressive strategies for optimization are daunting in this domain. This paper proposes a new way to leverage visual cues in HiLPR, a proposed uniform representation for parallel patterns. We show the application of this approach to three design patterns: Sparse Linear Algebra, Pipeline, and Shared Queue. An evaluation of the combination of a pattern's Forces with its Solution within this representation indicates that this approach holds promise in terms of assisting developers in making better-informed decisions about pattern implementation.

In computing clouds, it is desirable to avoid wasting resources as a result of under-utilization and to avoid lengthy response times as a result of over-utilization. In this paper, we propose a new approach for dynamic autonomous resource management in computing clouds. The main contribution of this work is two-fold. First, we adopt a distributed architecture where resource management is decomposed into independent tasks, each of which is performed by Autonomous Node Agents that are tightly coupled with the physical machines in a data center. Second, the Autonomous Node Agents carry out configurations in parallel through Multiple Criteria Decision Analysis using the PROMETHEE method. Simulation results show that the proposed approach is promising in terms of scalability, feasibility and flexibility.

Web content is notoriously difficult to capture on a printed page due to inconsistent and undesired results. Items that users may not want to print, such as media, navigation menus and more show up on their page. Other items that they may care about are truncated or spread across several pages. Some tools exist to help users with what is printed, but they often are cumbersome to use or are costly for a company to maintain. Therefore, we introduce PrintMonkey, which allows users to write their own printing templates and share them with others on the web. No modifications to the original webpages are required and users with less development experience can use and develop templates. A comparison with four alternative solutions reveals the concrete ways in which PrintMonkey improves upon existing approaches in terms of functionality, customizability and scalability.

Multi-core programming presents developers with a dramatic paradigm shift. Whereas sequential programming largely allowed the decoupling of source from underlying architecture, it is now impossible to develop new patterns and abstractions in isolation from issues of modern hardware utilization. Synchronization and coordination are now manifested at all levels of the software stack, and developers currently lack the essential tools to even partially automate reasoning techniques and system configuration management. As a first stage to addressing this problem, this paper proposes a framework for a tool suite designed to partially automate the acquisition and management of static system visualization in a feedback loop with dynamic execution properties. This model enables developers to find a best fit system configuration, potentially reconciling resource contention and utilization tensions that are critical to multi-core platforms. The application of a prototype of this suite, Deja View, demonstrates how tool support can aid reasoning about causally related sets of changes across system artifacts.

Clustered Objects (COs) [1] have been proven to be an effective abstraction for improving scalability of systems software [2, 3]. But can we devise a programming model that would allow COs to live outside the specialized environments of these operating systems and still provide benefit? This paper presents an overview of SCOPE (Scalable COs with Portability Events), a prototype user-level library derived from the original implementation of COs in the K42 OS. Our initial results indicate that not only do the benefits of COs hold, but that the notion of a "portability event", responsible for maintaining the runtime environment of COs, provides a powerful programming model that will enable COs to be seamlessly transplanted into systems beyond K42. This paper overviews this programming model, provides details and preliminary results from its prototype implementation in SCOPE, and provides motivation to consider simple language mechanisms to further support portability events and this programming model in general.

Operating system structure is important; it leads to understandable, maintainable, 'pluggable' code. But despite our best efforts, some system elements have been difficult to structure. We propose a new analysis of this problem, and a new technology that can structure these elements. Aspect-oriented programming (AOP) (G. Kiczales et al., 1997) uses linguistic mechanisms to support the separation of crosscutting elements, or aspects of the system, from primary functionality. We have developed a proof-of-concept AOP implementation of prefetching in FreeBSD (www.cs.ubc.ca/labs/spl/aspects/aspectc.html). In our implementation, we have been able to modularize prefetching.

Layered architecture in operating system code is often compromised by execution path-specific customizations such as prefetching, page replacement and scheduling strategies. Pathspecific customizations are difficult to modularize in a layered architecture because they involve dynamic context passing and layer violations. Effectively they are vertically integrated slices through the layers. An initial experiment using an aspect-oriented programming language to refactor prefetching in the FreeBSD operating system kernel shows significant benefits, including easy (un)pluggability of prefetching modes, independent development of prefetching modes, and overall improved comprehensibility. Keywords aspect-oriented programming, software modularity, operating system design 1.

The benefits of Markov-based predictive prefetching have been largely overshadowed by the overhead required to produce high-quality predictions. While both theoretical and simulation results for prediction algorithms appear promising, substantial limitations exist in practice. This outcome can be partially attributed to the fact that practical implementations ultimately make compromises in order to reduce overhead. These compromises limit the level of algorithm complexity, the variety of access patterns and the granularity of trace data that the implementation supports. This paper describes the design and implementation of GMS-3P (Global Memory System with Parallel Predictive Prefetching), an operating system kernel extension that offloads prediction overhead to idle network nodes. GMS-3P builds on the GMS global memory system, which pages to and from remote workstation memory. In GMS-3P, the target node sends an online trace of an application's page faults to an idle node that is running a Markov-based prediction algorithm. The prediction node then uses GMS to prefetch pages to the target node from the memory of other workstations in the network. Our preliminary results show that predictive prefetching can reduce the remote-memory page fault time by 60% or more and that, by offloading prediction overhead to an idle node, GMS-3P can reduce this improved latency by between 24% and 44%, depending on the Markov model order.

Advances in network technology continue to improve the communication performance of workstation and PC clusters, making high-performance workstation-cluster computing increasingly viable. These hardware advances, however, are taxing traditional host-software network protocols to breaking point. A modern gigabit network can swamp a host's IO bus and processor, limiting communication performance and slowing computation unacceptably. Fortunately, host-programmable network processors used by these networks present a potential solution. Offloading selected host processing to these embedded network processors lowers host overhead and improves latency. This paper examines the use of embedded network processors to improve the performance of workstation-cluster global memory management. We have implemented a revised version of the GMS global memory system that eliminates host overhead by as much as 29% on active nodes and improves page fault latency by as much as 39%.