[ECOS] eCos in FOSDEM

Peter Vandenabeele peter.vandenabeele@mind.be
Tue Jan 28 14:03:00 GMT 2003


On Tue, Jan 28, 2003 at 03:49:59PM +0200, Harri Siirtola wrote:
> Hi,
> 
> I tried to find more info about when and where the eCos meeting is. I read 
> somewhere that it's not 100% certain that the public meeting will take 
> place, it depends on number of attendants. Is the schedule clear already?

Harri,

There are 2 elements:

1. below is the program and abstract list of the embedded & kernel track
   that we organized (Nick will make an eCos presentation on Sunday).

2. there is an open eCos meeting planned by the eCos maintainers, and it
   is suggested to ue the embedded room for that (e.g. during the
   breakfasst we planned at 10:00 - 11:00 ?).. Jonathan will organize
   that.
> I'm still not sure if it's useful for me to attend. Which kind of 
> developers is it best for? Digging into the bowels of eCos or building 
> applications (the latter is my case, no deep knowledge about eCos itself)?

Fosdem is  D-2-D event (Developer to developer) and completely NON-commercial.
Entrance is entirely free. Organisation is a little bit ad-hoc, but it was
a succes recent years. This year, we have for the first time this embedded
and kernel development track. On Saturday we also have lectures of Rchard 
Stallman and John Maddog Hall. More info on fosdem.org and subscrbe to the
mailing list. 

> Does anyone know if any material will appear in the net or published otherwise?

- presentations and photos are typically published on fosdem.org and 
  associated sites.

> Thanks,
> 	Harri

+++++++++++++++++

Saturday 8/2/2003
=================

14:00 - 14:45 : Keynote
                opencores.org : free hardware development
                                Speaker : Richard Herveille

14:45 - 15:30 : Adapting Debian for Embedded Use
                                Speaker : Martin Michlmayr 

16:00 - 16:45 : Portable programming on complex systems 
                                Speaker : Peter De Schrijver

16:45 - 17:30 : Wonka  - a JVM for embedded systems
                                Speaker : Chris Gray

Sunday 9/2/2003
===============

10:00 - 11:00 : breakfast + BoF's

11:00 - 11:45 : Cross-compiling in embedded systems
                                Speaker : Eero Tamminen

11:45 - 12:30 : eCos
                                Speaker : Nick Garnett

14:00 - 14:45 : RTAI
                                Speaker : Philippe Gerum

14:45 - 15:30 : GNU Bayonne and real-time issues in freely licensed
                telephony software
                                Speaker : David Sugar

15:30 - 16:15 : Using C++ for real-time extensions to the Linux kernel
                                Speaker : Peter Soetens

++++++++++++++++

List of abstracts for embedded and kernel development track at 
fosdem 2003, Sat 8 and Sun 9 Feb 2003, Brussels

Version of 28 Jan 2003, changes in the program are still possible

Saturday 8 Feb 2003:
--------------------

KEYNOTE:

OPENCORES - A REPOSITORY OF OPEN SOURCE HARDWARE IP CORES
---------------------------------------------------------
  Richard Herveille
  www.opencores.org

  OpenCores is a repository of open source freely available Intellectual 
  Property (IP) cores. It is the hardware counterpart of the free software 
  movement. Currently OpenCores hosts 185 projects, maintained by 657 
  developers. Many projects are still in the development stage and some 
  will never reach maturity. But 65 projects are currently mature enough 
  to be used in designs.

  In order to start development access to tools is required. For software 
  development the GNU toolchain provides a solid foundation. For hardware 
  development freely available tools are either not (yet) available, or 
  simply not mature enough. Testing is an even bigger problem. Software 
  can be tested on the same system it is being developed, by simply running 
  the program. Hardware can be tested by running simulations, but testing 
  IP cores in real hardware always requires some form of programmable logic. 
  Fortunately FPGA vendors provide an array of test and development boards 
  for their devices. Also the major FPGA vendors are releasing 'lite' 
  versions of their synthesis and Place&Route tools. This proved to be a 
  major boost for open source hardware projects.

  IP cores need to be interconnected via a common bus. OpenCores adopted the 
  'WISHBONE System-on-Chip (SoC) Interconnect Architecture for Portable IP 
  Cores', or WISHBONE bus for short. WISHBONE provides a common, logical 
  interface between IP cores. This improves portability and reliability of 
  the system, and results in faster time to market. Especially when combining 
  a multitude of cores from different designers from different backgrounds. 
  Currently OpenCores maintains stewardship over the WISHBONE standard.

  To prove the concept of OpenCores and the quality of the cores available 
  from OpenCores we created a System-on-Chip (SoC). All IP cores needed to 
  build the SoC are available from OpenCores. The used cores include a 32bit 
  RISC (OpenRISC), JTAG Test Access Port for the OpenRISC, memory controller, 
  UART, 10/100 Ethernet MAC, VGA controller, PS/2 keyboard controller, and 
  an AC97 audio controller.

  The 32bit OpenRISC 1200 forms the heart of the SoC. It is the first 
  available implementation of the OpenRISC 1000 architecture. The i
  OpenRISC 1000 architecture is available under the GNU LGPL license.

  The OR1200 main features are:
  * Open and free architecture
  * Linear 32bit logical address space
  * Harvard architecture, separate data and instruction busses
  * Simple and uniform length instruction set, 32bits opcode, 32/64bits data
  * 32 entries general purpose register file
  * 1 Branch delay slot
  * 8 KByte 1-way direct mapped instruction cache
  * 8 KByte 1-way direct mapped data cache
  * 64 entry hash based 1-way direct mapped TLB Instruction Memory Management unit (IMMU)
  * 64 entry hash based 1-way direct mapped TLB Data Memory Management unit (DMMU)
  * Power management module
  * JTAG Test Access Port debug module
  * Tick timer module
  * Programmable interrupt controller

  Software development for the OpenRISC 1000 Architecture is supported by a 
  genuine GNU Toolchain Port and an advanced Architectural Simulator. A 
  uCLinux port is also available, RTEMS and Linux ports are under development.

  To conclude the presentation a demo will be shown using the working 
  System-on-Chip.


ADAPTING DEBIAN FOR EMBEDDED USE
--------------------------------
  Martin Michlmayr

  Traditionally, it has been common to develop a home grown operation system
  for embedded use.  However, according to a study carried out by Evans Data
  Corporation, there is a shift towards adopting standard systems, in
  particular such based on embedded Linux.  This is partly due to the fact
  that embedded systems are nowadays as powerful as desktop systems were not
  too long ago.  While embedded systems still have unique requirements, they
  are now more comparable to desktop systems than ever.  This suggests the
  possibility that a standard operating system and its applications can be
  taken and adapted for embedded usage.  The focus will be on the changes
  required in Debian to be better suited for embedded use.  In particular,
  crucial changes to Debian's powerful package management system, dpkg, will
  be discussed.  For example, embedded systems must avoid installing files
  which occupy storage but do not provide required functionality.  This
  includes documentation and translation files.  The iPKG package manager,
  closely related to dpkg, but developed specifically to meet the needs
  to embedded systems, will be presented.  Additionally, for embedded use,
  large applications have to be replaced by smaller programs with similar
  functionality.  BusyBox, which combines tiny versions of many common UNIX
  utilities into a single small executable, is important in this regard.
  Also, it will be discussed what is needed to replace bash with dash, a
  POSIX compliant shell much smaller than bash.  Alternatives to the powerful
  but big libc6 library, such as dietlibc, will be presented.


PORTABLE PROGRAMMING ON COMPLEX SYSTEMS
---------------------------------------
  Peter De Schrijver

  Portable programming is an important requirement for system level programming, 
  especially in embedded systems. However, as CPU and system architectures have 
  become more complex over the years, this is a growing challenge. System 
  programmers have to cope with such things as noncoherent I/O, out of order 
  memory accesses, various busses and address tranlations next to things like 
  endianess mismatches and alignment issues.
  We will discuss these issues and give ideas on how to build a device
  driver framework to allow for portable system programming.


WONKA - A JVM FOR EMBEDDED SYSTEMS
----------------------------------
  Chris Gray

  Wonka is a clean-room implementation of the Virtual Machine and class library 
  specifications for Java, developed by Belgian company Acunia. It was 
  developed specifically to meet Acunia's needs for Java in embedded and mobile 
  systems. Wonka is Java2 compliant, and supports the CDC/FC profile plus some 
  additional packages. A selective JIT compiler is currently under test.
  
  Wonka is available under a BSD licence. In this presentation we will discuss 
  some of the challenges involved in implementing a high level of Java 
  functionality in an embedded context, and outline some current areas of 
  development and research.


Sunday 9 Feb 2003:
------------------

CROSS COMPILING IN EMBEDDED SYSTEMS
-----------------------------------
  Eero Tamminen

  Abstract not yet available.


eCos (EMBEDDED CONFIGURABLE OPERATING SYSTEM)
---------------------------------------------
  Nick Garnett

  eCos is a highly configurable, portable, open source, royalty free 
  Operating System for real time embedded applications. This presentation 
  provides a brief, mainly technical, overview of eCos: its history, 
  implementation, configuration system and future directions.
  
  One of the key technological innovations in eCos is a highly 
  sophisticated configuration system. The configuration system allows the 
  application writer to impose their requirements on the run-time 
  components, both in terms of their functionality and implementation. 
  eCos provides both a graphical configuration tool that runs on both 
  Windows and Linux, and a command line tool that can be used to automate 
  the configuration process.
  
  eCos is designed to be portable to a wide range of target architectures 
  and target platforms including 16, 32, and 64 bit architectures, MPUs, 
  MCUs and DSPs. The eCos kernel, libraries and runtime components are 
  layered on the Hardware Abstraction Layer (HAL), and thus will run on 
  any target once the HAL and relevant device drivers have been ported to 
  the target's processor architecture and board. Currently eCos supports a 
  large range of different target architectures (ARM, Intel StrongARM and 
  XScale, Hitachi SH3/4, Intel x86, MIPS, Matsushita AM3x, NEC V850, 
  Motorola PowerPC, SPARC and several others), including many of the 
  popular variants of these architectures and evaluation boards.
  
  eCos has been designed to support applications with real-time 
  requirements, providing features such as full preemptability, minimal 
  interrupt latencies, and all the necessary synchronization primitives, 
  scheduling policies, and interrupt handling mechanisms needed for these 
  type of applications. eCos also provides all the functionality required 
  for general embedded application support including device drivers, 
  memory management, exception handling, networking, file systems, 
  standard C and math libraries, POSIX and uITRON compatibility etc.
  
  To permit proprietary application code to be linked with eCos without 
  itself being forced to be released under the GPL, eCos is distributed 
  under the GPL license with an exception. It is also royalty and buyout 
  free, making it an attractive alternative to license inhibited, closed 
  source or commercial real-time operating systems.
  

RTAI
----
  Philippe Gerum

  RTAI is a GNU/Linux-based real-time interface for applications with
  strict timing constraints which has recently been ported over Adeos, a
  flexible environment for sharing hardware resources among concurrent
  operating systems.
  
  We will discuss the process of migrating the RTAI core over the Adeos
  nanokernel, describing the pipelining scheme Adeos implements in order
  to dispatch hardware and system events to RTAI, so that real-time
  tasks have absolute priority over regular Linux activities.
  
  We will conclude by considering the new paths this migration opens for
  extending RTAI while still keeping a high degree of determinism.


GNU BAYONNE AND REAL-TIME ISSUES IN FREELY LICENSED TELEPHONY SOFTWARE
----------------------------------------------------------------------
  David Sugar
  http://www.gnu.org/software/bayonne

  In understanding the needs of building current and next generation telephony
  services we have to consider that in the past such services were often built from
  proprietary realtime operating systems. Changes in the last 20 years in the power
  and capabilities of commercial off the shelf commercial platforms and free oper-
  ating systems have largely replaced the need for specialized proprietary realtime
  systems, but not the realtime requirements that still exist today. This paper is meant
  to provide an overview and introduction of the challenges and needs in providing
  realtime Linux services to support current and next generation telephone networks,
  but is not meant to be a rigorous analysis on the topic.


USING C++ FOR REAL-TIME EXTENSIONS TO THE LINUX KERNEL
------------------------------------------------------
  Peter Soetens

  The Linux kernel is well known for its portability and extendability.
  One of the recent extensions is bringing realtime operating systems
  under the kernel hood so that realtime software can run on the same
  platform as the user(-space) programs. Examples are RTAI (www.rtai.org)
  and RTLinux (www.fsmlabs.com). Since realtime programs introduce a
  complexity far beyond device drivers, better programming methodologies
  become a must to control the realtime softwares complexity. The C++
  programming language facilitates object oriented development and design,
  which can be used to manage complex programs. There are reports of
  realtime operating systems being written entirely in C++ (e.g. eCos,
  (http://sources.redhat.com/ecos/). 

  I will introduce how the Linux kernel can be extended to support
  C++ to the extent that all C++ programs can be brought in the kernel,
  except for exceptions. A second logical step is to bring the standard
  C++ library into the kernel, which will also be explained.

-- 
Before posting, please read the FAQ: http://sources.redhat.com/fom/ecos
and search the list archive: http://sources.redhat.com/ml/ecos-discuss



More information about the Ecos-discuss mailing list