2010 Summer Undergraduate Research in Engineering (SURE) Projects

Computer Science and Engineering (CSE)

Directions: Below are listed the most recent descriptions of 2010 SURE projects available in CSE. Please consider this list carefully before applying to the SURE program (http://www.engin.umich.edu/gradadmissions/sure/index.html). You are welcome to contact faculty if you have additional, specific questions regarding these projects. After your application is received (in late January), you will be contacted and asked to list your top three projects, in order of preference. You are also welcome to list these preferences on your application, although this is by no means required.

CSE Project 1: Low Cost, Low Power Processor Design for Developing World Applications
Faculty Mentor: David Blaauw blaauw@umich.edu
Prerequisites: VLSI Design I (e.g. EECS 427); VLSI Design II (e.g. EECS 627)

We are developing a chip design targeting developing work applications, in particular a "talking book" developed Literacy bridge.  Our chip will dramatically reduce the cost of these devices making them more readily available to developing world regions.   Students will participate in chip design and testing of a commercial grade processor using an ARM architecture.


CSE Project 2: Developing a Low-cost, Low-power Audio Computer
Faculty Mentor: Peter Chen pmchen@umich.edu
Prerequisites: Familiarity with at least 4 of the following 6 topics: digital logic (e.g. EECS 270), data structures and algorithms (e.g. EECS 281), computer organization / architecture (e.g. EECS 370), microprocessor based systems (e.g. EECS 373), digital signal processing (e.g. EECS 451), operating systems (e.g. EECS 482)

Students will participate in designing and implementing a low-cost, low-power audio computer, which is intended for use in developing regions for applications in education, health care, and agriculture.  Students can work on a wide variety of topics, such as audio-based user interaction, audio-based communication, caching algorithms for slow memories, file systems, and and operating systems.


CSE Project 3: Engineering Social Networking
Faculty Mentor: Valeria Bertacco valeria@umich.edu
Prerequisites: Programming in C or C++; web programming and databases are a plus

Online social networks are a growing internet phenomenon: they connect millions of individuals through sharing of common interests, political and religious views, careers, etc.  How can we make this large volume of information useful?  Our research group strives to study interesting aspects of social networks by deploying  some of the solutions, commonly used in Electronic Design Automation (EDA), to explore and verify Finite State Machines (FSMs). The long standing EDA practice to analyze very large graphs  through specialized formalisms and abstractions promises to provide valuable results also in the context of social networks.


CSE Project 4: Computer Games with a Purpose
Faculty Mentor: Valeria Bertacco valeria@umich.edu
Prerequisites: Programming in Java; web programming is a plus

Can computer games be more than a diversion?  Help us develop a massively multiplayer computer game to solve Boolean satifiability problems, a difficult class of computer science problems. Traditional approaches fail to solve large, complex instances.  Perhaps humans can do a better job if they are motivated by a game.  Can you help us expand our single player prototype into a massively multiplayer online game?  Check out the game prototype at funsat.eecs.umich.edu


CSE Project 5: Infallible Chips
Faculty Mentor: Valeria Bertacco valeria@umich.edu
Prerequisites: Programming in C++ and perl

Semiconductor technology will soon allow to manufacture microchips composed of billions of transistors. While this allows us to build cheaper and more powerful computers, these new devices will be much more prone to failure than today's microchips. We are currently working on studying the effects of hardware faults on computers composed of dozens of processors. In particular, we want to study what is the impact of these failures on the software programs running on the processor and how to design the system so that failures do not corrupt programs' results.

During your project you will work on developing a software model to simulate a full system hardware/software environment, inject faults in the system and research various approaches to guarantee that it can deliver correct results even in face of faults. You will learn about System on Chip architecture, reliability in microprocessor, and become familiar with parallel programming paradigms.


CSE Project 6: Multicores That Never Make Mistakes
Faculty Mentor: Valeria Bertacco valeria@umich.edu
Prerequisites: Basic hardware design skills in Verilog or VHDL

Networks on a chip (NoCs) are small networks built in multi-core processors and other systems-on-a-chip.  It is practically impossible to design these systems so they are completely correct because they are very complex and unpredictable.  For instance, it is very hard to predict the patterns of traffic in the network, because they depend on the software programs running in the system-on-a-chip.  Moreover, if the network breaks then the entire system may fail.

We are working on designing a hardware solution that makes sure that the NoC is always working correctly, even if the design is incorrect.  If and when the network is about to fail, our solution intervenes and guarantees that all traffic in flight reaches its destination.  In this project, you will research ways to design and implement such a solution.  The project will also be a great opportunity to learn about NoCs, hardware design and verification.


CSE Project 7: Secure Hardware for the Masses
Faculty Mentor: Todd Austin austin@umich.edu
Prerequisites: Programming in C or C++ or hardware design skills

It is hard to write good software.  Nearly every large system out there crashes, has security vulnerabilities, and it is difficult to maintain.  The effects of these bad programs can be felt from the nearly $60 billion the US economy loses annually because of software bugs, to the final report you lose due to a malware infestation.  Our lab is working on hardware mechanisms to make it easier to find and fix software bugs and security vulnerabilities.  For example, we have designed additions to a processor that can search out potential programming errors while the software is running normally.  One of our biggest challenges is making the work of these additions invisible to the user so that they are not inconvenienced by any loss of performance.  We have multiple places where your skills and interests can be useful: we work on compilers, operating systems, and digital circuit design.  We will be working with a fully-functional processor in an FPGA and the entire software stack built on top of it. You will come away from this project with a much better understanding of computer systems from the ground up, and a stronger grasp of C/C++, scripting, and Verilog programming skills.


CSE Project 8: Visual Sonification
Faculty Mentor: Todd Austin austin@umich.edu
Prerequisites: Programming in C/C++; basic computer architecture knowledge a plus

Do you hear what I see?  There are millions of people in the world who are vision impaired and you have the chance to help them see with their ears.  We are bringing together multiple disciplines to convert the world into sound so that the blind can recognize specific items, recognize their current location, and navigate enclosed areas.  This project requires techniques from computer vision, computer architecture, robotics, and 3D audio processing.  We are looking for talented people to work with us in developing this system in various ways, from refining the 3D audio to helping develop the experiments for testing.  The project will require working in C, C++ and also provide opportunities for working with the OpenCV (Open Computer vision library), csound (Open Sound Library) and embedded hardware.


CSE Project 9: Development of a 3D Human-robot Interface Using the iPhone
Faculty Mentor: Edwin Olson ebolson@umich.edu
Prerequisites: Strong programming skills, previous experience with iphone development and OpenGL preferred.

Increasingly, robots are becoming interactive partners with humans. We are developing user-friendly ways of interacting with robots using ubiquitous devices like iPhones. The goal of this project is to develop a user interface for the iPhone that can be used to control a robot and to visualize the data being collected by the robot. Such an interface, implemented using a 3D graphics system, would allow the user to view the world either from the robot's perspective (in an augmented or virtual reality type of display) or from a top-down view--- whichever is most suitable for the task at hand.
The student will develop native 3D applications for iPhone/iTouch, capable of displaying 3D data sent to it from a robot.


CSE Project 10: Vision and LIDAR Based Pedestrian Tracking
Faculty Mentor: Edwin Olson ebolson@umich.edu
Prerequisites: Strong Java programming skills, previous robotics experience preferred; previous experience in state estimation (e.g. Kalman filter) and/or classification algorithms (support vector machines / AdaBoost) are pluses.

One of the challenges in the MAGIC 2010 robotics competition is to track pedestrians. We wish to identify pedestrians in camera and LIDAR data, classify them as either "good guys" or "bad guys" based on their clothing, and produce high-quality position and velocity estimates. The student's responsibilities will include developing detection, classification, and tracking algorithms. If successful, the algorithms will be incorporated into our team's software.


CSE Project 11: Building Semantically-labeled Maps of Large Urban Environments Using Teams of Robots
Faculty Mentor: Edwin Olson ebolson@umich.edu
Prerequisites: Strong Java programming skills, previous robotics experience preferred; experience with state estimation (e.g. Kalman Filter) and machine vision are pluses.

We are building a large team of robots capable of autonomously exploring an urban environment both indoors and outdoors. The data collected from these robots (which includes camera and laser data) must be collected and presented to a human user in convenient manner. For example, attaching semantic labels to objects ("tree", "doorway") makes the resulting data more useful. The student's responsibilities will be to process data collected by the robots and produce an interactive 3D model of the environment.


CSE Project 12: Compiler Analysis Techniques for Concurrent Software
Faculty Mentor: Scott Mahlke mahlke@umich.edu
Prerequisites: Strong C++ programming experience (e.g. EECS 280 and EECS 281); knowledge of concurrent programming with Pthreads is recommended but not required; knowledge of compilers is helpful but not required

The goal of the Gadara is to remove the responsibilities traditionally placed upon human programmers for deadlock avoidance in multi-threaded programs and instead create a feedback controller that is automatically synthesized from application software source code.  The feedback control logic is then inserted and compiled with the application source code.  When the instrumented code is run, it avoids deadlocks by throttling threads when they acquire various sets of resources.  Compiler analysis is used to identify the portions of the application that can potentially develop deadlocks.  The team has built a first prototype that implements this approach.  It takes as an enhanced control flow graph (CFG) produced by the compiler.  This CFG is translated into a Petri net model, which is then pruned and analyzed using techniques from Discrete Control Theory.  Following the results of the analysis, a feedback controller is automatically synthesized using the method of supervision based on place invariants for Petri nets.  However, the current prototype relies heavily on the programmer to guide and manage the analysis.  The goal of this project is to fully automate the approach, wherein the compiler is responsible for discovering information such as lock/unlock pairs and lock pointer sets.  The project consists of two graduate students, one in the discrete control area and one in the compiler side - a student on this project will work with both, most closely with the compiler student to construct the second generation prototype of the Gadara deadlock avoidance system.


CSE Project 13: Ninja Programmers
Faculty Mentor: Igor Markov imarkov@eecs.umich.edu
Prerequisites: Eligible students will have successfully completed a project-driven course in algorithms and data structures with C++, such as EECS 281.  More advanced experience in programming or algorithms can be useful.  Reasonable written and verbal communication skills are required.

Ninja programmers produce exceptionally efficient software by using less-known analysis and coding techniques.  In this project, we will improve the performance of several optimization algorithms by employing memory prefetching, branch expectations, profile-driven and architecture-specific optimizations, SSE instructions and multithreading.  Ninja programmers operate either individually or in small teams.


CSE Project 14: Predicting Success in Temporal Lobe Surgery for Epilepsy
Faculty Mentor: Zeeshan Syed zhs@umich.edu
Prerequisites: Algorithms and data structures; probability; programming experience; signals and systems or signal processing (preferred but not required)

Epilepsy affects over 3 million people in the United States, and is the second most common cause of mental health disability, particularly among young adults. Unfortunately, many of these cases cannot be successfully controlled even with multiple anticonvulsant drugs. Surgery for temporal-lobe epilepsy, one of the most common syndromes, may not only control seizures, but also prevent untimely death. There is a wide variation, however, in terms of the efficacy and safety of these procedures. Our work attempts to more precisely predict which patients will benefit from temporal lobe surgery. We do this by studying large amounts of electroencephalographic (EEG) data to find markers that are associated with high or low risk surgical cases. This work is inherently multi-disciplinary, and lies at the intersection of machine learning, data mining, signal processing, and applied algorithms.


CSE Project 15: Predicting Cardiac Arrhythmias
Faculty Mentor: Zeeshan Syed zhs@umich.edu
Prerequisites: Signal processing; substantial programming experience; data mining or machine learning (preferred but not required)

Cardiovascular disease is the leading cause of death around the world. There are an estimated 1.5 million heart attacks in the U.S. each year, and nearly half a million deaths take place each year due to cardiac-related causes. In this context, the large volumes of cardiovascular data that are collected in hospitals and during the course of clinical trials present an exciting opportunity to advance patient care by capturing prognostic phenomena associated with specific cardiac conditions, and by providing fresh insights into disease dynamics over long time scales. The focus of our work is to discover novel risk markers for cardiac arrhythmias using sophisticated computational methods for the structured analysis of large multi-signal, multi-patient datasets. These risk markers can be used to develop real-time methods for improved prognosis and intervention.


CSE Project 16: Computational Strategic Reasoning
Faculty Mentor: Michael Wellman wellman@umich.edu
Prerequisites: Programming ability; interest/background in economics, game theory, and/or statistics (helpful though not required)

The Strategic Reasoning Group develops computational tools to support reasoning about complex strategic scenarios, including trading in markets (e.g., financial, supply chains, Internet advertising), games (e.g., poker), and other applications.  The undergraduate researcher will support development and analysis of strategies for some of these domains, in preparation for an international competition (e.g., the Trading Agent Competition, http://tradingagents.org) or as part of a related research effort.


CSE Project 17: Integrating AI Engine (Soar) with Unreal 3
Faculty Mentor: John Laird laird@umich.edu
Prerequisites: CS 2 level class - data structures and algorithms (EECS 281); good knowledge of C++

The project involves integrating an existing AI engine (Soar) with the Unreal 3 game engine. During the first stage of the project, the student(s) will write interface code that connects the two software systems together - translating internal Unreal data structures into perceptual information for Soar agents, and translating commands from Soar into Unreal bot actions. The second stage of the project will be building agents in Soar.


CSE Project 18: iPhone Vs. gPhone: Use Your Smartphone as Sensors
Faculty Mentor: Z. Morley Mao zmao@umich.edu
Prerequisites: Programming in C or C++ or Java (e.g. EECS 280 and EECS 281)

We are collecting a diverse set of data from tens of thousands of smartphone users about network performance and power usage to gain a better understanding of why sometimes applications on smartphones are much slower than expected.  Worse yet, they may quickly deplete your battery!  The students will work with an established team of graduate students on various system issues in designing better smartphone applications, analyzing usage data of existing popular applications, and designing novel applications to exploit the phone platform as a sensor to monitor network performance, for instance.  Students will have hands-on experience programming on smartphones, measuring energy consumption of various applications, testing security properties, etc.


CSE Project 19: Unwanted Traffic: Stop the Spam in Emerging Networks
Faculty Mentor: Z. Morley Mao zmao@umich.edu
Prerequisites: Programming in C or C++ or Java (e.g. EECS 280 and EECS 281)

We all receive spam in our email accounts.  Spams in other networks such as cellular networks can be potentially more damaging, e.g., voice spam, MMS or SMS spam. This project can take the perspective of an attacker or a defender (or both) by identifying vulnerabilities of existing smartphone applications to be exploited for sending spam or attacked through spam, as well as by devising defense mechanisms to detect such malicious traffic.  We will also explore spam in online social networks.


CSE Project 20: Database-driven Analysis of Gene Expression Data   
Faculty Mentor: H. V. Jagadish jag@umich.edu
Prerequisites: Must have taken at least 4 college level biology classes and at least 2 college level computing classes.

Objectives:    If you are interested in the intersection of Biology and Computing, this project is for you. I am a Computer Scientist, looking for students who have Biological training, to improve technqiues for bioinformatics analyses of high throughput data.