<?xml version="1.0" encoding="ISO-8859-1" ?>
<rss version="2.0"
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  
     xmlns:ev="http://purl.org/rss/1.0/modules/event/" 
     xmlns:dc="http://purl.org/dc/elements/1.1/"
>
 <channel>
  <title>URCS Seminars &amp; Talks</title>
  <link>http://www.cs.rochester.edu/dept/seminar</link>
  <description>Upcoming Seminars &amp; Talks from the Computer Science Department at the University of Rochester</description>
  <language>en-us</language>
  <image>
   <url></url>
   <title>Computer Science Department, University of Rochester</title>
   <link>http://www.cs.rochester.edu/dept/seminar</link>
  </image>
  <lastBuildDate>Mon, 16 Nov 2009 10:30:47 -0500</lastBuildDate>
  
   <item>
    <title>Xipeng Shen: Making Programs Learn as Birds Do ---Input-Centric Program Behavior Analysis and Optimizations</title>
    <link>http://www.cs.rochester.edu/dept/seminar/view/431</link>
    <description>[Monday, November 23, 2009 at 11:00 AM in Computer Studies Bldg. Room 209] Unlike a bird, which can learn to fly better and better, existing
programs are sort of dumb---the one millionth run of a program is
typically not a bit better than the first-time run. One of the main
reasons is the insufficient consideration of program inputs in current
program optimizations. The limitation has resulted in a set of
shortcomings that have prevented the current programming systems from
meeting the new challenges imposed by the continuous increases in
hardware parallelism and software complexity.

Input-centric program behavior analysis is a technique for intelligent
programming systems. The key is the concentration on program input, a
factor deciding program behavior but having been insufficiently
understood and exploited. Input-centric behavior analysis opens the
door to evolvable computing, where, the optimizer learns program
behavior patterns incrementally across production runs, and improves
the program continuously. Just as a bird learns to fly better and
better, in evolvable computing, a program may learn to run faster and
faster.

This talk will focus on the influence of program inputs on program
behaviors, the handling of input complexity, and the modeling of the
connections between inputs and runtime behaviors through incremental
statistical learning. The effectiveness of input-centric analysis is
demonstrated in its applications in enhancing runtime optimizations in
Java Virtual Machine, improving cost-efficiency in software
speculation, and alleviating optimization obstacles for GPU (Graphic
Processing Unit) programs.

Bio:  Xipeng Shen has been an assistant professor at The College of William
and Mary since 2006. He received his Ph.D. and Master degree in
Computer Science from University of Rochester in 2006 and 2003
respectively. He received the M.S. degree in Pattern Recognition from
Chinese Academy of Sciences in 2001, and the B.S. degree from The
North China University of Technology.  Xipeng Shen&#39;s main research
lies in the area of Compiler Technology and Programming Systems,
covering Optimizing Compilers, Parallel Computing, GPU Computing,
Program Behavior Analysis, etc.  He leads the Compilers and Adaptive
Programming Systems research group at The College of William and
Mary. The group have been focusing on integrating automatic learning,
adaptation, and evolvement into different computing layers to form a
whole-system synergy.

 Refreshments will be provided at 10:45</description>
    <ev:startdate>20091123T160000Z</ev:startdate>
    <ev:enddate>20091123T170000Z</ev:enddate>
    <guid>http://www.cs.rochester.edu/dept/seminar/view/431</guid>
   </item>
  
   <item>
    <title>Dr. Arun Chauhan: Higher-Level Programming on Parallel Computers: Sweetening the Deal for Users (and Making Compilers Work Harder)</title>
    <link>http://www.cs.rochester.edu/dept/seminar/view/432</link>
    <description>[Monday, November 30, 2009 at 11:00 AM in Computer Studies Bldg. Room 209] A recent article in Communications of the ACM proposed that programming be considered the fourth &#39;R of literacy.  Several eminent computer scientists have also started campaigning for treating computer science as a fundamental field of science.  The core premise behind both is that today computational methods have become a cornerstone of problem solving in a diverse set of domains. A consequence of this is an explosion in the number and variety of high performance applications.  Novel domain-specific high-level languages have been invented to satisfy the new base of users, who are often not expert programmers.  This has resulted in a challenging problem for programming language implementers---an increasingly diverse set of users wanting to write high performance applications on the one hand, and a moving target of complex modern computers on the other.

We need better software tools---compilers, in particular---to bridge this widening gap between modern highly abstract programming languages and sophisticated heterogeneous hardware architectures.  At IU we are engaged in addressing this problem on several fronts.  In this talk I will focus on two.  I will argue that we need to dramatically change our way of thinking about programs to be able to build more capable compilers, by moving the focus from counting the number of computational steps to paying attention to data access patterns.  I will propose a model to analyze such patterns and a method to implement it.  I will then extend the problem to the analysis and optimization of parallel programs and propose a novel approach to specifying parallelism that complements the earlier analysis.  This allows the compiler to focus on what it does best---optimizing programs, freeing the human users to do what they do best---optimizing domain-specific algorithms. 

Bio:  Arun Chauhan got a Bachelors in Electrical Engineering and Masters in Computer Science from the Indian Institute of Technology, Delhi.  After a stint in marketing and another programming parallel machines, he returned to school to get a PhD from Rice University.  Since 2006 Arun Chauhan has been an Assistant Professor at the School of Informatics and Computing at Indiana University.  His primary research interests are in compiling, parallel computing, and high-level programming languages.


Refreshments provided at 10:45 AM</description>
    <ev:startdate>20091130T160000Z</ev:startdate>
    <ev:enddate>20091130T170000Z</ev:enddate>
    <guid>http://www.cs.rochester.edu/dept/seminar/view/432</guid>
   </item>
  
   <item>
    <title>Robbert Van Renesse: Refining the way to Consensus</title>
    <link>http://www.cs.rochester.edu/dept/seminar/view/451</link>
    <description>[Monday, December 07, 2009 at 11:00 AM in Computer Studies Bldg. 209] Consensus protocols, typically a dozen or so lines of high-level pseudo-code,
are notoriously difficult to comprehend.  For this reason, they are usually accompanied
by correctness proofs, but few people are prepared to slog through those details.  And
although the proofs should constitute a way to understand the protocols, they are
rarely illuminating and do not distinguish between important insights and the myriad of
low-level technical details that also need to be right.  So people are more likely to do
operational reasoning, where they look at various hand-simulated sample executions 
and attempt to understand how and why the protocols work based on those.  
Moreover, little effort is made to relate the different protocols even though all seem to
be constructed from a relatively small number of underlying mechanisms, such as
rounds of messaging and quorum intersection.  We present a different approach to
understanding consensus protocols.  Specifically, we present a sequence of
specifications of consensus with gradually increasing lower-level detail. Each such
refinement step involves an important insight about how and why consensus protocols
work.

 
Bio: Robbert Van Renesse is a Principal Research Scientist at the Department of
Computer Science. He received his Ph.D. from the Vrije Universiteit in Amsterdam in
1989 where he developed the Amoeba Distributed Operating System. Subsequently he
worked on the Plan 9 operating system at AT&amp;T Bell Laboratories. Since joining Cornell
in 1991 he has worked on fault-tolerant distributed systems.  Robbert van Renesse is a
co-founder of D.A.G. Labs, which was acquired by FAST Search &amp; Transfer, which was
acquired by Microsoft, and a co-founder of Reliable Network Solutions, Inc.
 

 Refreshments provided at 10:45</description>
    <ev:startdate>20091207T160000Z</ev:startdate>
    <ev:enddate>20091207T170000Z</ev:enddate>
    <guid>http://www.cs.rochester.edu/dept/seminar/view/451</guid>
   </item>
  
   <item>
    <title>Rocco Servedio: TBA      </title>
    <link>http://www.cs.rochester.edu/dept/seminar/view/453</link>
    <description>[Monday, January 25, 2010 at 11:00 AM in Computer Studies Bldg. 209] </description>
    <ev:startdate>20100125T160000Z</ev:startdate>
    <ev:enddate>20100125T170000Z</ev:enddate>
    <guid>http://www.cs.rochester.edu/dept/seminar/view/453</guid>
   </item>
  
 </channel>
</rss>
