<< GCC Gathering 2011 | GNU Tools Cauldron 2013 >>

Date: July 9 to 11, 2012. Location

Charles University, Prague, Czech Republic Department of Maths and Physics Malostranske Namesti 25 118 00 Praha 1 map1, map2

Registration Fee: No charge. This event is completely funded by the workshop sponsors.

The cake

To celebrate 25th anniversary of GCC all present hackers gathered around a cake representing VT-100 terminal displaying the original announcement of the project to sing the free software song composed by RMS under lead of our release manager Richard Guenther.

free_software_song.pdf

Schedule

The schedule for the workshop can be accessed here.

The conference booklet is booklet.pdf.

We will be running all the presentations registered in advance as a single stream (Stream 1 in the schedule). Presentations registered on the first day of the workshop will likely need to run in a parallel stream (Stream 2 in the schedule).

Presentations have been assigned 45 minute slots (ideally 30min for the presentation and 15 min for questions). If you think you will need more or less time, please contact us at tools-cauldron-admin@googlegroups.com .

Organizers

IUUK (Computer Science Institute, Charles University)

CE-ITI (Institute for Theoretical Computer Science)

Google

Organizing committee:

Jan Hubicka

Diego Novillo

Ian Taylor

AdaCore

Google

IBM

Red Hat

Mailing lists

Abstract submissions, registration, administrivia questions: tools-cauldron-admin@googlegroups.com Announcements and discussions related to the conference: gcc@gcc.gnu.org .

Workshop description

We are pleased to announce another gathering of GNU tools developers. The basic format of this meeting will be similar to the last one at the Google offices in London (http://gcc.gnu.org/wiki/GCCGathering2011).

The purpose of this workshop is to gather all GNU tools developers, discuss current/future work, coordinate efforts, exchange reports on ongoing efforts, discuss development plans for the next 12 months, developer tutorials and any other related discussions.

We will meet at the Lesser Town Campus of Charles University in Prague (Malostranske Namesti 25, Prague, Czech Republic map1, map2).

We are inviting every developer working in the GNU toolchain: GCC, GDB, binutils, runtimes, etc. The basic format of the meeting will be similar, but in addition to discussion topics selected at the conference, we are looking for advance submissions.

If you have a topic that you would like to present, please submit an abstract describing what you plan to present. We are accepting three types of submissions:

Prepared presentations: demos, project reports, etc.

BoFs: coordination meetings with other developers.

Tutorials for developers. No user tutorials, please.

Note that we will not be doing in-depth reviews of the presentations. Mainly we are looking for applicability and to decide scheduling. There will be time at the conference to add other topics of discussion, similarly to what we did at the London meeting.

To register your abstract, send e-mail to tools-cauldron-admin@googlegroups.com .

Your submission should contain the following information:

Title:

Authors:

Abstract:

If you intend to participate, but not necessarily present, please let us know as well. Send a message to tools-cauldron-admin@googlegroups.com stating your intent to participate.

Accomodation

The conference venue can be conveniently reached by the public transport, either by Metro (subway, underground train) line A (green line), to the station of Malostranská and then by a short walk, or by the tramway lines No. 12, 20 or 22 to the stop of Malostranské náměstí. The tramway stop is situated right across the square to the conference venue. A public traffic schemes can be downloaded at http://www.dpp.cz/en/transport-around%20prague/transit-schematics/.

Because of the location just in the center of Prague, it is easy to check lodging options on common booking sites, like http://www.marys.cz/.

Some options in walking distance from the venue include:

Hotel U tří pštrosů**** Address: Dražického náměstí 12, Prague 1 Room prices:from 109 EUR/night (prices include breakfast) Distance to venue: 5 minutes walk http://www.utripstrosu.cz/

Hotel Waldstein**** Address: Valdštejnské náměstí 6, Prague 1 Room prices:from 89 EUR/night (prices include breakfast) Distance to venue: 3 minutes walk (just around the corner) http://www.hotelwaldstein.cz/en/hotel.html

Hotel Kampa Garden**** Address: U Sovových mlýnů 9, Prague 1 Room prices: single: from 100 EUR/night (prices include breakfast) Distance to venue: 8 minutes walk http://www.kampagarden.cz/en/

Hostel Sokol Address: Nosticova 2, Prague 1 Room prices: dorms (6-14 beds): 350 CZK (15 EUR)/night | double: 900 CZK (37 EUR)/night (prices do not include meals) Distance to venue: 10 minutes walk or 1 stop by tram http://www.hostelsokol.cz/



Presentations

Keynote Presentation - Free software, GNU and GCC

Presenter: Richard Stallman

The free software movement's goals, and how GNU and GCC are part of achieving them.

Temporary location of the video recording: http://kam.mff.cuni.cz/~hubicka/rms/rms.html

Download: OGG Video

Status of High-Level Loop Optimizations in GCC

Presenter : Richard Guenther

Slides : pdf

Video: part 1, part 2

We will present the state of high-level loop optimizations in GCC. Trying to come up with a viable path forward several alternatives are present as basis for discussion.

GDB Roadmap

Presenter : Jan Kratochvil

Slides : pdf

Video: video

Status of missing features, status of features being worked on (known to me). Which way to keep unused template methods code separate from the code output. Dynamic types (such as variable length arrays) implementation choices in GDB.

Finding races and memory errors with GCC instrumentation (AddressSanitizer)

Presenters : Konstantin Serebryany and Dmitriy Vyukov

Slides: pdf

We will present two dynamic testing tools based on compile-time instrumentation. AddressSanitizer (ASan) finds memory bugs, such as use-after-free and out-of-bound accesses to heap, stack and globals. This tool could be seen as a partial replacement for Valgrind and similar tools. The major advantages over Valgrind are the speed (less than 2x slowdown on average) and the ability to handle bugs related to stack and globals.

AddressSanitizer can also fully replace Mudflap. ThreadSanitizer (TSan) finds data races. It uses the same race detection algorithm as the Valgrind-based TSan, but compile-time instrumentation allows it to be much faster (2x-4x slowdown). Both tools are implemented using GCC and LLVM infrastructures, so we will provide a comparison between GCC and LLVM from our perspective. We will also share our experience in deploying theses testing tools in large software projects.

More info:

Fission

Presenter : Cary Coutant

Slides : pdf

Video: part 1, part 2

Fission is about improving debugger usability and link-time performance. We've designed DWARF extensions that allow us to split the bulk of the debug information from the object files, allowing us to substantially reduce total link time and the size of the linked binary. In addition, because the input files to the linker are significantly smaller, bandwidth needed for a distributed build system is also reduced. The final executable will contain an index of the debug information, allowing the debugger to locate the debug information on demand, so that debugger start-up time can also be reduced. A full description of the project is on the GCC wiki: http://gcc.gnu.org/wiki/DebugFission.

Control-flow preservation in GCC for safety-critical uses

Presenter : Olivier Hainque

Slides : pdf

Video: part 1, part 2

The proposed presentation is about the introduction of a "-fpreserve-control-flow" option in GCC, which directs the compiler operations so that the control-flow expressed in a source persists in the generated assembly code.

The interest is twofold:

Facilitate source to object traceability analysis, sometimes required as part of safety critical certification processes

Allow non-intrusive coverage analysis using an instrumented execution environment instead of program instrumentation, also attractive in certification contexts Beyond traceability analysis requirements, control flow preservation is key to support the non-intrusive analysis of coverage criteria that care about source boolean expressions and their operands, such as the "Decision" or "MCDC" coverage metrics in the avionics certification area (DO178-B standard).

The basic idea is to allow inferring which values were taken by boolean operands or expressions from information on the execution flow at the corresponding machine branch points (provided by the instrumented execution environment). Very roughly, we need the relevant branches to remain there and accurate enough debug info to map them to source expressions in presence of arbitrarily complex constructs, which poses a few challenges to solve in the compiler.

At this point, we have a stable implementation in our local gcc 4.5 series, supporting optimizations up to -O1. We use this to offer a non-intrusive coverage analysis framework, using valgrind or qemu as virtual execution environments instrumented to produce execution traces.

We are about to port this to gcc 4.7 and would be happy to contribute to mainline after exchanging with other developers on the approach.

The presentation will include an introduction to the

major motivations for this work

general implementation scheme

challenges encountered and resolutions

current status & results

future plans

Free Software: A viable model for Commercial Success

Presenter : Robert Dewar

Slides : pdf

Video: part 1, part 2

This talk will discuss our experience at AdaCore, one of only a handful of 100% Free Software companies. All of our commercial products are licensed under the GPL and other Free Software Licenses. People often assume that there is a conflict between the use of such licenses and the needs of a commercial software company. Our experience at AdaCore shows that on the contrary, the Free Software model can be very successful both for us as a company and for our customers. We think this model can be used in many other circumstances, and want to encourage free software enthusiasts to consider this model in other circumstances.

Video of the talk: http://www.youtube.com/watch?v=PwRUk7KD8mc

Compiler Optimizations for Dynamic Scripting Language Interpreters and JITs

Presenter : David Edelsohn

Video: part 1, part 2

Modern Dynamic Scripting Languages such as Python, Ruby and PHP traditionally have been implemented as interpreters written in C. With their increasing usage in web frameworks and cloud computing infrastructure, they frequently are deployed on GNU/Linux systems, which means they are compiled with GCC. This presentation will examine compiler optimizations that can improve the performance of these types of languages. As performance demands of these languages increase, some implementations are turning to JITs and this talk will explore some compiler features that assist JITs for these languages.

An implementation of predicated value numbering

Presenter: Michael Matz

I'm talking about my ongoing work to replace the current value numberer with one capable to deal with predicates (i.e. value numbers depending on condition), with hopefully also some other advantages over the current one.

Improving Function Pointer Security for Virtual Method Dispatches

Presenter : Caroline Tice

Slides: pdf

A common vector of attack in C++ programs is for attackers to make use of use-after-free bugs in the program to overwrite vtable pointers and hijack program execution. If the attacker discovers a use-after-free bug in the program, he waits until the object has been freed, then re-allocates the same memory to be an object of the same size and overwrites the vtable pointer in that object. When the object is accessed by the program (the use-after-free bug), it uses the attacker's vtable pointer to then go and start executing the attacker's code.

We are working on an approach to detect when attackers have overwritten vtable pointers, without significant performance penalties, and without changing the C++ ABI.

The Local Register Allocator Project

The Local Register Allocator (LRA) project is focused on replacing famous GCC reload pass. The project history, motivation and goals, and the different considered approaches to LRA implementation are discussed. LRA overview and structure, tasks solved by LRA, the current state of the project including SPEC2000 bechmark results on some major platforms are given.

The future of LRA project and possible new RA optimizations which utilize new CPU features could be implemented on the base LRA are discussed.

What's New in C++11

The second revision of the C++ language standard, C++ 2011, was ratified last year, thirteen years after the first one. In this talk, I will discuss notable additions to the language since C++98/03.

Towards feature parity of GDB remote and native debugging

Presenter: Ulrich Weigand

GDB supports debugging applications running natively on the host systems as well as debugging applications running on a remote system. In the latter case, GDB talks to a remote stub on the target side. If the target system is running Linux, this remote stub is usually gdbserver, which comes as part of the GDB distribution itself. In principle, there should be no difference between debugging a Linux process natively and debugging it remotely via gdbserver. However, for historical reasons, the GDB native Linux target is implemented as a completely separate code base from gdbserver. This has over time led to the unfortunate situation that certain GDB features are in fact only available when debugging natively (and other features are available only when debugging remotely). I'm planning to present an overview of the current state of affairs, including a couple of improvements that were implemented recently. I'm also planning to discuss proposals how to move forward, ideally towards a goal of achieving feature parity between native and remote/gdbserver debugging by actually sharing a single code base.

The Quest for Cheaper Variable Tracking in GCC

Presenter : Alexandre Oliva

Slides : pdf

Video: video

GCC's variable tracking pass got visibly more expensive with the introduction of VTA, Variable Tracking at Assignments. The pass scans each basic block for insns relevant for variable location debug information generation, propagates locations and values across basic blocks with global dataflow analysis, and finally generates notes with location or value expressions for variables.

The last part has been recently improved from an algorithm whose worst case was exponential to one that is linear on the variable/value equivalence graph size. The other parts have gained some memory savings by keeping global equivalences in a global data structure rather than in per-block equivalence sets, but there's need and room for performance improvements, particularly in the confluence operation in dataflow analysis.

The goal of this session is to present the current inner workings of the variable tracking pass, including the recent changes and exisiting plans, then opening for discussion, requests and suggestions of further improvements.

GDB vs. MPI (Message Passing Interface)

Presenters : Joachim Protze and Andreas Knüpfer

Slides : pdf

Video: video

The MPI (Message Passing Interface) standard is the one established method to achieve highest scale parallelism on today's biggest supercomputers. There are many implementations including free ones. Yet the standard makes life for debuggers pretty difficult.

The MPI API hides away all sorts of management information in handles to give maximum flexibility to implementors. Unfortunately, this includes data type information of all messages. Therefore, debuggers are pretty much unable to show the contents of messages that are exchanged between parallel processes.

We implemented a solution for GDB using two stages: one to collect data type information from the MPI API and a GDB plugin to print a message's contents in a correct and convenient way. With this, GDB and MPI work together like they should have in the first place ... in our opinion.

New programming abstractions for concurrency

Presenter : Torvald Riegel

Slides: pdf

Parallelization is becoming more important than in the past, and for more developers. Parallel code often results in a concurrent execution of parts of the program (i.e., when threads do not execute truly in parallel but have to coordinate or synchronize with each other). Because concurrent code is typically more complex than sequential code, we need to provide programming abstractions that make these tasks easier for programmers.

In this talk, I will first give a brief overview of concurrency and the associated programming challenges, and then describe two programming abstractions that have been recently added to GCC: the C++11/C11 atomics and Transactional Memory. Both are based on the C++11/C11 memory model, which I will also introduce.

Supporting Parallel Component Debugging Using the GDB Python Interface

Presenters : Kevin POUGET, Miguel SANTANA, Jean-François MEHAUT and Vania Marangozova-Martin

Slides : pdf

Video: video

In this presentation, we will introduce the work we have undertaken in a join R&D effort of STMicroelectronics and the Laboratoire d'Informatique de Grenoble on the GDB project.

In the context of parallel and embedded computing, debugging is well- recognized as a complex activity. Nowadays, such applications are not developed anymore from scratch, relying only on the programming language primitives. Instead, they lean upon more advanced programming models allowing an easier expression of parallelism.

Interactive debuggers like GDB evolved from their earlier times when they could only handle machine instructions to support the source languages used by developers to write their applications. We believe that their next evolution could be the support of programming models, which would help the developers to manipulate higher level abstractions like the entities or communication mechanisms defined by the programming model. These abstractions will have the advantage of being closer to the concepts the developer dealt with during development time and they will help her to keep focused on application execution behaviour.

Hence, our work consists in improving GDB towards the support of such programming models. On top of GDB's Python interface, and extending it with contributed patches whenever it was required, we prepared a framework supporting the debugging of an ST home-made embedded component framework for MPSoC systems, running on an x86 simulator. The presentation will detail how we leveraged GDB to gather relevant runtime information about the component framework and the set of new features we developed, along with use-cases about their usage.

Reducing DWARF debuginfo size

Presenters : Cary Coutant and Mark Wielaard

Video: video

Generating, linking, reading and storing DWARF debuginfo take significant resources, time and space. ï¿½We want to discuss some efforts that have recently been done to reduce some of that in the compiler, linker, package manager and tools, like debuggers, that use the DWARF debug information. ï¿½We are interested in discussing efforts that worked, the various tradeoffs, efforts that didn't produce significant results and ideas for future DWARF reduction work and/or standardization.

Towards Multicore GDB

Presenter : Stan Shebs

Video: video

Multicore systems have been around for a while, but the next generation takes it to a whole new level, with high-performance embedded designs consisting of anywhere from 30 to 1,000 cores. GDB needs significant work to be useful in debugging these targets, both in user interface and to improve performance.

The first part of the task is to expand GDB's vocabulary by formalizing the notion of core as its own first-class object, conceptually similar to a thread but persistent, and by introducing the "process/thread/core set", by which the user works with groups of threads, cores, etc, rather than just one at a time.

The second part is to partition the debugging workload so that GDB is less of a bottleneck. For instance, we introduce the notion of an agent library that can run on each core and handles some tasks locally, such as testing of a breakpoint condition, only notifying GDB when the condition is true.

This presentation will review the current status of multicore work, and look ahead to additional ideas to facilitate debugging of future multicore systems.

The Cilk Plus Implementation on GCC

Presenters : Balaji V. Iyer, Robert Geva and Pablo Halpern.

Slides: pdf

In the current era of multicore processors, it is necessary for programmers to write efficient code to exploit their full capabilities. In this presentation, we address the Intel (r) Cilk(tm) Plus language extension that is implemented in a GCC branch. Cilk Plus is a set of language constructs for C/C++ for data and task parallelism.

The first construct defines three keywords (_Cilk_spawn, _Cilk_sync and _Cilk_for) that can be used on an existing serial program to make it task parallel. The keywords are simple to use, make the program easy to read and provide strong guarantees of serial equivalence. However, they require the help of a runtime whose source is also included in the compiler branch.

The other components in Cilk Plus provide data-parallelism constructs. Array notations aid the compiler to schedule batches of iterations to execute in parallel. If the processor has vectorization support, this construct can assist the compiler to vectorize the code. In addition, there are built-in functions that provide intrinsic operations such as finding maximum/minimum, sum and product of all the array elements. Second, elemental functions provide an option to take a scalar function in standard C and C++ and deploy it on many elements of arrays without prescribing an order of operations among the array elements. This allows the compiler to generate a vector version of the function, which vectorizes across a batch of consecutive calls to the elemental function. Finally, we provide a pragma and a set of clauses called pragma SIMD that allow users to communicate intent for vector execution and certain pertinent information to ease the job of the compiler in generating vector code.

In the first part of the presentation, we explain all the components of Cilk Plus. After this, we walk-through the compiler modifications in GCC and present some of the performance that can be achieved on some common benchmarks that were converted to Cilk Plus. We end the presentation with some future work and optimization opportunities in the compiler.

GCC Doc Futures

Presenter: Benjamin Kosnik

A complete survey of gcc documentation: what exists, in what formats and why, outstanding legal issues in the GPL vs. GFDL war, where documentation is located in the source, install, and website, how documentation is packaged for releases, how patches are tracked for release notes, how porting information and other derived/contributed information can be made part of canonical GCC documentation sources. A method for integrating wiki content into canonical manuals will be proposed. Known issues with the current documentation will be enumerated, and the audience will be queried and otherwise inspired/cajoled into contributing a more complete list of known issues. Priorities will be assigned to this derived list of known issues, and volunteers solicted to implement solutions in time for the next major gcc release.

Slides : pdf

Wiki: http://gcc.gnu.org/wiki/DocumentationOverviewIssues

Pre-Parsed Headers

Presenters : Lawrence Crowl and Diego Novillo

Slides: pdf

In this talk we will discuss the status of the pre-parsed headers (PPH) project. In particular, we will describe implementation challenges, the current state of the PPH branch, lessons learned during implementation and future plans.

C++ Conversion BoF

Presenters : Lawrence Crowl and Diego Novillo

Slides : pdf

Wiki: http://gcc.gnu.org/wiki/cxx-conversion

G++ diagnostics: present and (near) future

Presenter: Paolo Carlini and Dodji Seketeli

Between the 4.6 and the 4.7 releases series a lot of work went into the C++ front-end (and the preprocessor) to improve the diagnostics and add new warnings, even without mentioning hundreds of fixes for many new and long standing bugs: eg, -ftrack-macro-expansion, PR c++/48934, -Wdelete-non-virtual-dtor, -Wzero-as-null-pointer-constant. Most definitely, 4.8 will get some form of "caret diagnostics" and more work is ongoing. Still, from many points of view, Clang++ still has an edge, for example ranges, "typedef unwrapping", spell checker, etc. Which kinds of improvements we would like to see in GCC as soon as possible? Which ones are doable with a moderate effort and which require extended infrastructural work? Which diagnostic we would like to handle differently than Clang?"

Straight-line strength reduction in GCC

Presenter : Bill Schmidt

Slides : pdf

Video: part 1, part 2

GCC has long lacked a strength reduction capability outside of loops. Previous attempts to address this within existing frameworks, such as partial redundancy elimination, have not been successful. A primary reason for this is that these frameworks process individual expressions independently. For strength reduction, a determination of profitability often requires examining chains of related strength reduction candidates. This short presentation will demonstrate the issues involved and outline a new SSA dominator-based proposal for efficiently performing non-loop strength reduction.

Identifying compiler options to minimize energy consumption by embedded programs

Presenter : Jeremy Bennett

Slides : pdf

Video : video

During this summer, Embecosm will be running a joint project with Bristol University Department of Computer Science to look at the impact of compiler options on energy consumption by programs on embedded processors. Many people have opinions on this, but it transpires there is very little hard data. Bristol University's equipment can measure the power consumed by a processor in great detail and to fine time resolution. We will test a representative range of programs (suggestions will be solicited from the audience) with a wide range of compiler options. We will use a number of different processors (XMOS, ARM) as well as different processors in the same family (ARM). We will also compare GCC to LLVM. The results will be published in an open access journal to provide a baseline data set for future research. One channel we wish to pursue subsequently is use of MILEPOST technology to automatically select the best low energy options when compiling programs. The project, starting on 9 July, will be led by Jeremy Bennett (Embecosm) and Simon Hollis (Bristol University), with the work carried out by James Pallister of Embecosm, who will then return to Bristol University for a 3-year PhD in this field. The purpose of this talk is to solicit views from the wider GCC community at the start of this project, particularly with regard to the features of GCC that are most likely to yield benefits and should thus be explored. We look forward to presenting the results at next year's meeting.

The Benefit of GCC's open structure on instrumentation in the HPC area

Presenters:Johannes Ziegenbalg and Bert Wesarg (Technische Universität Dresden)

Function instrumentation is one foundational method of performance data gathering. This data is stored on disc in event trace files to run a performance analysis later on. Unfortunately, automatic instrumentation often results in lots of trace events being generated during the measurement run, especially in high-performance computing applications. This may alter the program behavior due to a large runtime-overhead. Additionally, the trace file becomes to large to be analyzed efficiently. Therefore, instrumentation filtering is inevitable. Though GCC is one of the few compilers which support function instrument filtering at compile time without altering the source code, it's filtering is difficult, if not impossible, to control.

In our presentation, we talk about our achievements using the instrumentation framework InterAspect to generate a GCC plugin which provides better control over the instrumentation.

We also present our plans to reduce the induced overhead by improving the generated code from the function instrumentation.

Status of the x32 psABI

Presenter: H.J. Lu

This talk presents the current status of x32 psABI, which brings x86-64 features to 32-bit applications while keeping memory footprint to 32 bits. It will discuss the performance of the new ABI and the challenges it faces.

StarPU's C Extensions for Hybrid CPU/GPU Task Programming, or, An Experience in Turning a Clumsy API Into Language Extensions

Presenter : Ludovic Courtès

Slides: pdf

StarPU started as a run-time support library for hybrid CPU/GPU task programming, later supplemented by a GCC plug-in. The GCC plug-in allows programmers to annotate C code to describe tasks and their implementations. Each task may have one or more implementations, such as CPU implementations or implementations written in OpenCL.

StarPU's support library schedules tasks over the available CPU cores and GPUs, and is also responsible for scheduling any data transfers between main memory and GPUs.

This talk will present the rationale for StarPU's C extensions and describe them. We will then report on our experience turning a C API into convenient language extensions, and discuss this use case for GCC plug-ins.

PowerPC BoF

Presenter : Michael Meissner

Slides: pdf

GCC GNAT Ada in jet engine control systems

Presenter : Peter Garbett

Slides: pdf

How to reach the workshop

From the Airport

- by taxi: You can order a cab at a price about 500 CZK. Just say our address: "Malostranske namesti 25, Mathematics Faculty" - by airport shuttle: You can also order an airport minibus at a price of approx. 480 CZK, and say the same address as in the previous case. Suitable for small groups, you pay the same price for up to 4 people. - by public transport: - The Prague's Metro line A is not going to operate till Sunday in between stations Mustek and Dejvicka. This is the segment used by the usual route from the Airport to the Charles University building where the workshop is held. Here is route valid till Sunday 8th - Take bus no 119 to "Hradcanska" - Take tram no 20 and go 4 stations to "Malostranske Namesti" - Monday 9th and on: - Take bus no 119 to "Dejvicka" station (final stop). - Go to the tram station "Vitezne namesti" (approximately 200m). - Take tram no 20 and go 5 stations to the stop "Malostranske namesti". - You can buy an (Basic) 90-minute ticket using a vending machine at the airport at a price of 32 CZK. You have to validate it as you enter the bus.

- You can buy an (Basic) 90-minute ticket using a vending machine at the airport at a price of 32 CZK. You have to validate it as you enter the bus.

From the railway station "Hlavni nadrazi"

- by taxi: The same procedure as from the airport, the price should be about 250 CZK. - by public transport: - Go by subway C (red line) to the station "I.P. Pavlova" (two stations in direction of "Haje"). - Take tram no 22 and go 7 stations to the stop "Malostranske namesti". - You can buy an (Short-term) 30-minute ticket using a vending machine at the railway station at a price of 24 CZK. You have to validate it as you enter the subway zone.

- You can buy an (Short-term) 30-minute ticket using a vending machine at the railway station at a price of 24 CZK. You have to validate it as you enter the subway zone.

From the railway station "Nadrazi Holesovice"

- by taxi: The same procedure as from the airport, the price should be about 250 CZK. - by public transport: - Find a passage to the station of city transport (red buses, trams). You can also walk through the subway hall, but don't forget to mark your ticket. - Take tram no 12 and go 8 stations to the stop "Malostranske namesti". - You can buy an (Basic) 90-minute ticket using a vending machine at the railway station at a price of 32 CZK. You have to validate it as you enter the tram.

- You can buy an (Basic) 90-minute ticket using a vending machine at the railway station at a price of 32 CZK. You have to validate it as you enter the tram.

See the surroundings of Malostranske namesti from the aerial view and a street plan http://kam.mff.cuni.cz/reach/reachpic.html (330 kb).

Current timetables and fares of the public transport http://www.dpp.cz/en/.

In the building of the School of Informatics the workshop events will take place in 1st floor.

Getting to Airport