Index: trunk/softs/giet_tsar/block_device.h =================================================================== --- trunk/softs/giet_tsar/block_device.h (revision 620) +++ trunk/softs/giet_tsar/block_device.h (revision 620) @@ -0,0 +1,67 @@ +/* + * SOCLIB_LGPL_HEADER_BEGIN + * + * This file is part of SoCLib, GNU LGPLv2.1. + * + * SoCLib is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation; version 2.1 of the License. + * + * SoCLib is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with SoCLib; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + * + * SOCLIB_LGPL_HEADER_END + * + * Copyright (c) UPMC, Lip6, Asim + * Nicolas Pouillon , 2007 + * + * Maintainers: nipo + */ +#ifndef BLOCK_DEVICE_REGS_H +#define BLOCK_DEVICE_REGS_H + +enum SoclibBlockDeviceRegisters { + BLOCK_DEVICE_BUFFER, + BLOCK_DEVICE_LBA, + BLOCK_DEVICE_COUNT, + BLOCK_DEVICE_OP, + BLOCK_DEVICE_STATUS, + BLOCK_DEVICE_IRQ_ENABLE, + BLOCK_DEVICE_SIZE, + BLOCK_DEVICE_BLOCK_SIZE, +}; + +enum SoclibBlockDeviceOp { + BLOCK_DEVICE_NOOP, + BLOCK_DEVICE_READ, + BLOCK_DEVICE_WRITE, +}; + +enum SoclibBlockDeviceStatus { + BLOCK_DEVICE_IDLE, + BLOCK_DEVICE_BUSY, + BLOCK_DEVICE_READ_SUCCESS, + BLOCK_DEVICE_WRITE_SUCCESS, + BLOCK_DEVICE_READ_ERROR, + BLOCK_DEVICE_WRITE_ERROR, + BLOCK_DEVICE_ERROR, +}; + +#endif /* BLOCK_DEVICE_REGS_H */ + +// Local Variables: +// tab-width: 4 +// c-basic-offset: 4 +// c-file-offsets:((innamespace . 0)(inline-open . 0)) +// indent-tabs-mode: nil +// End: + +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 + Index: trunk/softs/giet_tsar/dma.h =================================================================== --- trunk/softs/giet_tsar/dma.h (revision 620) +++ trunk/softs/giet_tsar/dma.h (revision 620) @@ -0,0 +1,31 @@ +#ifndef DMA_REGS_H +#define DMA_REGS_H + +enum SoCLibDmaRegisters { + DMA_SRC = 0, + DMA_DST = 1, + DMA_LEN = 2, + DMA_RESET = 3, + DMA_IRQ_DISABLE = 4, + /***/ + DMA_SPAN = 0x400, +}; + +enum DmaStatusValues { + DMA_SUCCESS = 0, + DMA_READ_ERROR = 1, + DMA_IDLE = 2, + DMA_WRITE_ERROR = 3, +}; + +#endif + +// Local Variables: +// tab-width: 4; +// c-basic-offset: 4; +// c-file-offsets:((innamespace . 0)(inline-open . 0)); +// indent-tabs-mode: nil; +// End: +// +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 + Index: trunk/softs/giet_tsar/drivers.c =================================================================== --- trunk/softs/giet_tsar/drivers.c (revision 620) +++ trunk/softs/giet_tsar/drivers.c (revision 620) @@ -0,0 +1,954 @@ +/**************************************************************************************** +File : drivers.c +Written by Alain Greiner & Nicolas Pouillon +Date : december 2010 + +Basic drivers used by the GIET, that is running +on the MIPS32 processor architecture. + +The supported peripherals are: +- the SoClib pibus_multi_tty +- the SocLib pibus_timer +- the SocLib pibus_dma +- The SoCLib pibus_icu +- The SoCLib pibus_gcd +- The SoCLib pibus_frame_buffer +- The SoCLib pibus_block_device + +The following global parameters must be defined in the ldscript. +- NB_CLUSTERS : number of clusters +- NB_PROCS : number of processor per cluster +- NB_NTASKS : max number of tasks per processor +- NB_LOCKS : max number of supported spin_locks +- NB_TIMERS : max number of timers per processor + +The follobing base addresses must be defined in the ldscript +- seg_icu_base +- seg_timer_base +- seg_tty_base +- seg_gcd_base +- seg_dma_base +- seg_locks_base +- seg_fb_base +- seg_ioc_base +****************************************************************************************/ + +#include "drivers.h" +#include "icu.h" +#include "block_device.h" +#include "dma.h" + +struct plouf; + +////////////////////////////////////////////////////////////// +// various informations that must be defined in ldscript +////////////////////////////////////////////////////////////// +extern struct plouf seg_icu_base; +extern struct plouf seg_timer_base; +extern struct plouf seg_tty_base; +extern struct plouf seg_gcd_base; +extern struct plouf seg_dma_base; +extern struct plouf seg_locks_base; +extern struct plouf seg_fb_base; +extern struct plouf seg_ioc_base; + +extern struct plouf NB_CLUSTERS; +extern struct plouf NB_PROCS; +extern struct plouf NB_TASKS; +extern struct plouf NB_TIMERS; +extern struct plouf NB_LOCKS; + +#define in_drivers __attribute__((section (".drivers"))) +#define in_unckdata __attribute__((section (".unckdata"))) + +//////////////////////////////////////////////////////////////////////////////////////// +// Global uncachable variables for synchronization between drivers and ISRs +//////////////////////////////////////////////////////////////////////////////////////// + +in_unckdata int volatile _dma_status[256]; +in_unckdata int volatile _dma_busy[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; + +in_unckdata int volatile _ioc_lock = 0; +in_unckdata int volatile _ioc_done = 0; +in_unckdata int volatile _ioc_status; + +in_unckdata char volatile _tty_get_buf[256]; +in_unckdata int volatile _tty_get_full[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; + +in_unckdata char volatile _tty_put_buf[256]; +in_unckdata int volatile _tty_put_full[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; + +//////////////////////////////////////////////////////////////////////////////////////// +// Global uncachable variables for inter-task barriers +//////////////////////////////////////////////////////////////////////////////////////// + +in_unckdata int volatile _barrier_initial_value[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; +in_unckdata int volatile _barrier_count[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; +in_unckdata int volatile _barrier_lock[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; + +//////////////////////////////////////////////////////////////////////////////////////// +// Global uncachable variables for spin_locks using LL/C instructions +//////////////////////////////////////////////////////////////////////////////////////// + +in_unckdata int volatile _spin_lock[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; + +//////////////////////////////////////////////////////////////////////////////////////// +// mempcy() +// GCC requires this function. Taken from MutekH. +//////////////////////////////////////////////////////////////////////////////////////// +__attribute((used)) +in_drivers static void *memcpy(void *_dst, const void *_src, unsigned int size) +{ + unsigned int *dst = _dst; + const unsigned int *src = _src; + if ( ! ((unsigned int)dst & 3) && ! ((unsigned int)src & 3) ) + while (size > 3) { + *dst++ = *src++; + size -= 4; + } + + unsigned char *cdst = (unsigned char*)dst; + unsigned char *csrc = (unsigned char*)src; + + while (size--) { + *cdst++ = *csrc++; + } + return _dst; +} + +//////////////////////////////////////////////////////////////////////////////////////// +// _procid() +// Access CP0 and returns processor ident +// No more than 1024 processors... +//////////////////////////////////////////////////////////////////////////////////////// +in_drivers unsigned int _procid() +{ + unsigned int ret; + asm volatile( "mfc0 %0, $15, 1": "=r"(ret) ); + return (ret & 0x3FF); +} +//////////////////////////////////////////////////////////////////////////////////////// +// _segment_increment() +// Access CP0 to get the procid, and returns the address increment to access +// various peripherals (TTY, TIMER, ICU, DMA), in case of multiprocessors architectures. +// It uses the NB_PROCS and NB_CLUSTERS parameters to compute this increment: +// - increment = cluster_id*cluster_increment + local_id*local_increment +// - cluster_id = procid / NB_PROCS +// - local_id = procid % NB_PROCS +// - cluster_increment = 4G / NB_CLUSTERS +//////////////////////////////////////////////////////////////////////////////////////// +in_drivers unsigned int _segment_increment(unsigned int local_increment) +{ + unsigned int nprocs = (unsigned int)&NB_PROCS; + unsigned int nclusters = (unsigned int)&NB_CLUSTERS; + unsigned int cluster_increment = (0x80000000/nclusters)*2; + unsigned int pid = _procid(); + return (pid / nprocs)*cluster_increment + (pid % nprocs)*local_increment; +} +//////////////////////////////////////////////////////////////////////////////////////// +// _proctime() +// Access CP0 and returns processor time +//////////////////////////////////////////////////////////////////////////////////////// +in_drivers unsigned int _proctime() +{ + unsigned int ret; + asm volatile( "mfc0 %0, $9": "=r"(ret) ); + return ret; +} +//////////////////////////////////////////////////////////////////////////////////////// +// _procnumber() +// Returns the number of processsors controled by the GIET +//////////////////////////////////////////////////////////////////////////////////////// +in_drivers unsigned int _procnumber() +{ + return (unsigned int)&NB_PROCS * (unsigned int)&NB_CLUSTERS; +} +//////////////////////////////////////////////////////////////////////////////////////// +// _it_mask() +// Access CP0 and mask IRQs +//////////////////////////////////////////////////////////////////////////////////////// +in_drivers void _it_mask() +{ + int tmp; + asm volatile("mfc0 %0, $12" : "=r" (tmp) ); + asm volatile("ori %0, %0, 1" : "=r" (tmp) ); + asm volatile("mtc0 %0, $12" : "=r" (tmp) ); +} +//////////////////////////////////////////////////////////////////////////////////////// +// _it_enable() +// Access CP0 and enable IRQs +//////////////////////////////////////////////////////////////////////////////////////// +in_drivers void _it_enable() +{ + int tmp; + asm volatile("mfc0 %0, $12" : "=r" (tmp) ); + asm volatile("addi %0, %0, -1" : "=r" (tmp) ); + asm volatile("mtc0 %0, $12" : "=r" (tmp) ); +} +////////////////////////////////////////////////////////////////////// +// _dcache_buf_invalidate() +// Invalidate all cache lines corresponding to a memory buffer. +// This is used by the block_device driver. +///////////////////////////////////////////////////////////////////////// +in_drivers void _dcache_buf_invalidate(const void * buffer, size_t size) +{ + size_t i; + size_t dcache_line_size; + + // retrieve dcache line size from config register (bits 12:10) + asm volatile("mfc0 %0, $16, 1" : "=r" (dcache_line_size)); + + dcache_line_size = 2 << ((dcache_line_size>>10) & 0x7); + + // iterate on lines to invalidate each one of them + for ( i=0; i= ntimers) return -1; + if( register_index >= TIMER_SPAN ) return -1; + + timer_address = (int*)(base + increment + timer_index*TIMER_SPAN*4); + timer_address[register_index] = value; // write word + return 0; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _timer_read() +// Read a 32 bits word in a memory mapped register of the MULTI_TIMER +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _timer_read(size_t timer_index, size_t register_index, int* buffer) +{ + int* timer_address; + size_t ntimers = (size_t)&NB_TIMERS; + unsigned int base = (unsigned int)&seg_timer_base; + unsigned int increment = _segment_increment(ntimers*TIMER_SPAN*4); + + if( timer_index >= ntimers) return -1; + if( register_index >= TIMER_SPAN ) return -1; + + if( timer_index >= ntimers) return -1; + if( register_index >= TIMER_SPAN ) return -1; + + timer_address = (int*)(base + increment + timer_index*TIMER_SPAN*4); + *buffer = timer_address[register_index]; // read word + return 0; +} +/////////////////////////////////////////////////////////////////////////////////////// +// MULTI_TTY COMPONENT +// The total number of TTYs is equal to NB_CLUSTERS * NB_PROCS * NB_TASKS. +// - tty_address = seg_tty_base + _segment_increment(NB_TASKS*16) + task_id*16 +// - tty_index = proc_id*NB_TASKS + task_id +/////////////////////////////////////////////////////////////////////////////////////// +// _tty_write() +// Write one or several characters directly from a fixed length user buffer +// to the TTY_WRITE register of the TTY controler. +// It doesn't use the TTY_PUT_IRQ interrupt and the associated kernel buffer. +// This is a non blocking call : it test the TTY_STATUS register. +// If the TTY_STATUS_WRITE bit is set, the transfer stops and the function +// returns the number of characters that have been actually written. +// It returns -1 in case of error (proc_id or task index too large) +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _tty_write(char* buffer, int length) +{ + char* tty_address; + size_t ntasks = (size_t)&NB_TASKS; + size_t nprocs = (size_t)&NB_PROCS; + size_t nclusters = (size_t)&NB_CLUSTERS; + unsigned int base = (unsigned int)&seg_tty_base; + unsigned int increment = _segment_increment(ntasks*TTY_SPAN*4); + size_t pid = _procid(); + int nwritten = 0; + size_t tid; + int i; + + if( ntasks == 0 ) tid = 0; + else tid = _current_task_array[pid]; + + if( tid >= ntasks ) return -1; + if( pid >= nprocs*nclusters ) return -1; + + tty_address = (char*)(base + increment + tid*TTY_SPAN*4); + //tty_address = (char*)(base + tid*TTY_SPAN*4); + + for ( i=0 ; i < length ; i++ ) + { + if((tty_address[TTY_STATUS*4] & 0x2) == 0x2) break; + else + { + tty_address[TTY_WRITE*4] = buffer[i]; // write character + nwritten++; + } + } + return nwritten; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _tty_read() +// Fetch one character directly from the TTY_READ register of the TTY controler, +// and writes this character to the user buffer. +// It doesn't use the TTY_GET_IRQ interrupt and the associated kernel buffer. +// This is a non blocking call : it returns 0 if the register is empty, +// and returns 1 if the register is full. +// It returns -1 in case of error (proc_id or task_id too large or length != 1) +// The length argument is not used in this implementation, and has been +// introduced for future implementations. +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _tty_read(char* buffer, int length) +{ + char* tty_address; + size_t ntasks = (size_t)&NB_TASKS; + size_t nprocs = (size_t)&NB_PROCS; + size_t nclusters = (size_t)&NB_CLUSTERS; + unsigned int base = (unsigned int)&seg_tty_base; + unsigned int increment = _segment_increment(ntasks*TTY_SPAN*4); + size_t pid = _procid(); + size_t tid; + + if( pid > 7 ) tid = 0; + else tid = _current_task_array[pid]; + + if( length != 1) return -1; + if( pid >= nprocs*nclusters ) return -1; + if( tid >= ntasks ) return -1; + + tty_address = (char*)(base + increment + tid*TTY_SPAN*4); + + if((tty_address[TTY_STATUS*4] & 0x1) == 0x1) + { + buffer[0] = tty_address[TTY_READ*4]; + return 1; + } + else + { + return 0; + } +} +/////////////////////////////////////////////////////////////////////////////////////// +// _tty_read_irq() +// iAS it uses the TTY_GET_IRQ interrupt and the associated kernel buffer, +// that has been written by the ISR, this function does not access the TTY registers. +// It fetch one single character from the _tty_get_buf[tty_index] kernel buffer, writes +// this character to the user buffer, and reset the _tty_get_full[tty_index] buffer. +// This is a non blocking call : it returns 0 if the kernel buffer is empty, +// and returns 1 if the buffer is full. +// It returns -1 in case of error (proc_id or task_id too large, or length != 1) +// The length argument is not used in this implementation, and has been +// introduced for future implementations. +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _tty_read_irq(char* buffer, int length) +{ + int pid = _procid(); + int ntasks = (int)&NB_TASKS; + int nprocs = (int)&NB_PROCS; + int nclusters = (int)&NB_CLUSTERS; + int tty_index; + int tid; + + if( pid > 7 ) tid = 0; + else tid = _current_task_array[pid]; + + if( length != 1) return -1; + if( pid >= nprocs*nclusters ) return -1; + if( tid >= ntasks ) return -1; + + tty_index = pid*ntasks + tid; + if( _tty_get_full[tty_index] == 0 ) return 0; + + *buffer = _tty_get_buf[tty_index]; + _tty_get_full[tty_index] = 0; + return 1; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _exit() +// Exit (suicide) after printing message on a TTY terminal. +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _exit() +{ + char buf[] = "\n\n!!! Exit Processor !!!\n"; + int pid = _procid(); + + buf[24] = '0'; + buf[25] = 'x'; + buf[26] = (char)((pid>>8) & 0xF) + 0x30; + buf[27] = (char)((pid>>4) & 0xF) + 0x30; + buf[28] = (char)(pid & 0xF) + 0x30; + _tty_write(buf, 36); + + while(1) asm volatile("nop"); // infinite loop... +} + +/////////////////////////////////////////////////////////////////////////////////////// +// _icu_write() +// Write a 32 bits word in a memory mapped register of the ICU peripheral +// The base address is defined by the processor ID +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _icu_write(size_t register_index, int value) +{ + int* icu_address; + unsigned int base = (int)&seg_icu_base; + unsigned int increment = _segment_increment(ICU_SPAN*4); + + if( register_index >= ICU_SPAN ) return -1; + + icu_address = (int*)(base + increment); + icu_address[register_index] = value; // write word + return 0; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _icu_read() +// Read a 32 bits word in a memory mapped register of the ICU peripheral +// The ICU base address is defined by the processor ID +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _icu_read(size_t register_index, int* buffer) +{ + int* icu_address; + unsigned int base = (int)&seg_icu_base; + unsigned int increment = _segment_increment(ICU_SPAN*4); + + if( register_index >= ICU_SPAN ) return -1; + + icu_address = (int*)(base + increment); + *buffer = icu_address[register_index]; // read word + return 0; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _gcd_write() +// Write a 32 bits word in a memory mapped register of the GCD coprocessor +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _gcd_write(size_t register_index, int value) +{ + int* gcd_address; + if( register_index >= 4 ) return -1; + + gcd_address = (int*)&seg_gcd_base; + gcd_address[register_index] = value; // write word + return 0; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _gcd_read() +// Read a 32 bits word in a memory mapped register of the GCD coprocessor +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _gcd_read(size_t register_index, int* buffer) +{ + int* gcd_address; + if( register_index >= 4 ) return -1; + + gcd_address = (int*)&seg_gcd_base; + *buffer = gcd_address[register_index]; // read word + return 0; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _locks_write() +// Release a software spin-lock +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _locks_write(size_t index) + +{ + int max = (int)&NB_LOCKS; + if( index >= max ) return -1; + + _spin_lock[index] = 0; + return 0; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _locks_read() +// Try to take a software spin-lock. +// This is a blocking call, as there is a busy-waiting loop, +// until the lock is granted to the requester. +// There is an internal delay of about 100 cycles between +// two successive lock read, to avoid bus saturation. +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _locks_read(size_t index) +{ + int max = (int)&NB_LOCKS; + if( index >= max ) return -1; + + register int delay = ((_proctime() +_procid()) & 0xF) << 4; + register int * plock = (int *) &_spin_lock[index]; + + asm volatile ("_locks_llsc: \n" + "ll $2, 0(%0) \n" // $2 <= _locks_lock + "bnez $2, _locks_delay \n" // random delay if busy + "li $3, 1 \n" // prepare argument for sc + "sc $3, 0(%0) \n" // try to set _locks_busy + "bnez $3, _locks_ok \n" // exit if atomic + "_locks_delay: \n" + "move $4, %1 \n" // $4 <= delay + "_locks_loop: \n" + "addi $4, $4, -1 \n" // $4 <= $4 - 1 + "beqz $4, _locks_loop \n" // test end delay + "j _locks_llsc \n" // retry + "_locks_ok: \n" + ::"r"(plock),"r"(delay):"$2","$3","$4"); + return 0; +} +////////////////////////////////////////////////////////////////////////////////////////// +// I/O BLOCK_DEVICE +// The three functions below use the three variables _ioc_lock _ioc_done, +// and _ioc_status for synchronisation. +// - As the IOC component can be used by several programs running in parallel, +// the _ioc_lock variable guaranties exclusive access to the device. +// The _ioc_read() and _ioc_write() functions use atomic LL/SC to get the lock. +// and set _ioc_lock to a non zero value. +// The _ioc_write() and _ioc_read() functions are blocking, polling the _ioc_lock +// variable until the device is available. +// - When the tranfer is completed, the ISR routine activated by the IOC IRQ +// set the _ioc_done variable to a non-zero value. Possible address errors detected +// by the IOC peripheral are reported by the ISR in the _ioc_status variable. +// The _ioc_completed() function is polling the _ioc_done variable, waiting for +// tranfer conpletion. When the completion is signaled, the _ioc_completed() function +// reset the _ioc_done variable to zero, and releases the _ioc_lock variable. +// +// In a multi-tasks environment, this polling policy must be replaced by a +// descheduling policy for the requesting process. +/////////////////////////////////////////////////////////////////////////////////////// +// _ioc_get_lock() +// This blocking function is used by the _ioc_read() and _ioc_write() functions +// to get _ioc_lock using LL/SC. +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers void _ioc_get_lock() +{ + register unsigned int* plock = (unsigned int*)&_ioc_lock; + + asm volatile ("_ioc_llsc: \n" + "ll $2, 0(%0) \n" // $2 <= _ioc_lock + "bnez $2, _ioc_llsc \n" // retry if busy + "li $3, 1 \n" // prepare argument for sc + "sc $3, 0(%0) \n" // try to set _ioc_busy + "beqz $3, _ioc_llsc \n" // retry if not atomic + ::"r"(plock):"$2","$3"); +} +////////////////////////////////////////////////////////////////////////////////////// +// _ioc_write() +// Transfer data from a memory buffer to a file on the block_device. +// - lba : first block index on the disk +// - buffer : base address of the memory buffer +// - count : number of blocks to be transfered +// The source buffer must be in user address space. +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _ioc_write(size_t lba, void* buffer, size_t count) +{ + volatile unsigned int* ioc_address = (unsigned int*)&seg_ioc_base; + + // buffer must be in user space +// size_t block_size = ioc_address[BLOCK_DEVICE_BLOCK_SIZE]; +// if( ( (size_t)buffer + block_size*count ) >= 0x80000000 ) return -1; +// if( ( (size_t)buffer ) >= 0x80000000 ) return -1; + + // get the lock + _ioc_get_lock(); + + // block_device configuration + ioc_address[BLOCK_DEVICE_BUFFER] = (int)buffer; + ioc_address[BLOCK_DEVICE_COUNT] = count; + ioc_address[BLOCK_DEVICE_LBA] = lba; + ioc_address[BLOCK_DEVICE_IRQ_ENABLE] = 1; + ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_WRITE; + return 0; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _ioc_read() +// Transfer data from a file on the block device to a memory buffer. +// - lba : first block index on the disk +// - buffer : base address of the memory buffer +// - count : number of blocks to be transfered +// The destination buffer must be in user address space. +// All cache lines corresponding to the the target buffer must be invalidated +// for cache coherence. +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _ioc_read(size_t lba, void* buffer, size_t count) +{ + volatile unsigned int* ioc_address = (unsigned int*)&seg_ioc_base; + + // buffer must be in user space +// size_t block_size = ioc_address[BLOCK_DEVICE_BLOCK_SIZE]; +// if( ( (size_t)buffer + block_size*count ) >= 0x80000000 ) return -1; +// if( ( (size_t)buffer ) >= 0x80000000 ) return -1; + + // get the lock + _ioc_get_lock(); + + // block_device configuration + ioc_address[BLOCK_DEVICE_BUFFER] = (int)buffer; + ioc_address[BLOCK_DEVICE_COUNT] = count; + ioc_address[BLOCK_DEVICE_LBA] = lba; + ioc_address[BLOCK_DEVICE_IRQ_ENABLE] = 1; + ioc_address[BLOCK_DEVICE_OP] = BLOCK_DEVICE_READ; + + return 0; +} +/////////////////////////////////////////////////////////////////////////////////////// +// _ioc_completed() +// This blocking function cheks completion of an I/O transfer and reports errors. +// It returns 0 if the transfer is successfully completed. +// It returns -1 if an error has been reported. +/////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _ioc_completed() +{ + // waiting for completion + while (_ioc_done == 0) { asm volatile("nop"); } + + // reset synchronisation variables + _ioc_done = 0; + _ioc_lock = 0; + + // return errors + if((_ioc_status != BLOCK_DEVICE_READ_SUCCESS) && + (_ioc_status != BLOCK_DEVICE_WRITE_SUCCESS)) return -1; + else return 0; +} + +////////////////////////////////////////////////////////////////////////////////////// +// FRAME_BUFFER +// The _fb_sync_write & _fb_sync_read functions use a memcpy strategy to implement +// the transfer between a data buffer (user space) and the frame buffer (kernel space). +// They are blocking until completion of the transfer. +////////////////////////////////////////////////////////////////////////////////////// +// _fb_sync_write() +// Transfer data from an user buffer to the frame_buffer device with a memcpy. +// - offset : offset (in bytes) in the frame buffer +// - buffer : base address of the memory buffer +// - length : number of bytes to be transfered +////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _fb_sync_write(size_t offset, void* buffer, size_t length) +{ + volatile char* fb = (char*)(void*)&seg_fb_base + offset; + char* ub = buffer; + size_t i; + + // buffer must be in user space +// if( ( (size_t)buffer + length ) >= 0x80000000 ) return -1; +// if( ( (size_t)buffer ) >= 0x80000000 ) return -1; + + // memory copy + for(i=0 ; i= 0x80000000 ) return -1; +// if( ( (size_t)buffer ) >= 0x80000000 ) return -1; + + // memory copy + for(i=0 ; i= 0x80000000 ) return -1; +// if( ( (size_t)buffer ) >= 0x80000000 ) return -1; + + // waiting until DMA device is available + while (_dma_busy[pid] != 0) + { + for( i=0 ; i= 0x80000000 ) return -1; +// if( ( (size_t)buffer ) >= 0x80000000 ) return -1; + + // waiting until DMA device is available + while (_dma_busy[pid] != 0) + { + for( i=0 ; i 7 ) return 1; + + // parallel initialisation using atomic instructions LL/SC + asm volatile ("_barrier_init_test: \n" + "ll $2, 0(%0) \n" // read barrier_inital_value + "bnez $2, _barrier_init_done \n" + "move $3, %3 \n" + "sc $3, 0(%0) \n" // try to write barrier_initial_value + "beqz $3, _barrier_init_test \n" + "move $3, %3 \n" + "sw $3, 0(%1) \n" // barrier_count <= barrier_initial_value + "move $3, $0 \n" // + "sw $3, 0(%2) \n" // barrier_lock <= 0 + "_barrier_init_done: \n" + ::"r"(pinit),"r"(pcount),"r"(plock),"r"(value):"$2","$3"); + return 0 ; +} +////////////////////////////////////////////////////////////////////////////////////// +// _barrier_wait() +// This blocking function uses a busy_wait technics (on the barrier_lock value), +// because the GIET does not support dynamic scheduling/descheduling of tasks. +// The barrier state is actually defined by two variables: +// _barrier_count[index] define the number of particpants that are waiting +// _barrier_lock[index] define the bool variable whose value is polled +// The last participant change the value of _barrier_lock[index] to release the barrier... +// There is at most 16 independant barriers, and an error is returned +// if the barrier index is larger than 15. +////////////////////////////////////////////////////////////////////////////////////// +in_drivers int _barrier_wait(unsigned int index) +{ + register int* pcount = (int*)&_barrier_count[index]; + register int count; + + int lock = _barrier_lock[index]; + + if ( index > 15 ) return 1; + + // parallel decrement _barrier_count[index] using atomic instructions LL/SC + // input : pointer on _barrier_count[index] + // output : count = _barrier_count[index] (before decrementation) + asm volatile ("_barrier_decrement: \n" + "ll %0, 0(%1) \n" + "addi $3, %0, -1 \n" + "sc $3, 0(%1) \n" + "beqz $3, _barrier_decrement \n" + :"=&r"(count) + :"r"(pcount) + :"$2","$3"); + + // the last task re-initializes the barrier_ count variable + // and the barrier_lock variable, waking up all other waiting tasks + + if ( count == 1 ) // last task + { + _barrier_count[index] = _barrier_initial_value[index]; + asm volatile( "sync" ); + _barrier_lock[index] = (lock == 0) ? 1 : 0; + return 0 ; + } + else // other tasks + { + while ( lock == _barrier_lock[index] ) { } // busy waiting + return 0 ; + } +} +////////////////////////////////////////////////////////////////////////////////////// + + +// Local Variables: +// tab-width: 4; +// c-basic-offset: 4; +// c-file-offsets:((innamespace . 0)(inline-open . 0)); +// indent-tabs-mode: nil; +// End: +// +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 + Index: trunk/softs/giet_tsar/drivers.h =================================================================== --- trunk/softs/giet_tsar/drivers.h (revision 620) +++ trunk/softs/giet_tsar/drivers.h (revision 620) @@ -0,0 +1,108 @@ +/**************************************************************************************** + File : drivers.h + Written by Alain Greiner & Nicolas Pouillon + Date : september 2009 + + These system calls are used by the MIPS GIET, that is running + on the MIPS32 processor architecture. + + The supported peripherals are: + - the SoClib vci_multi_tty + - the SocLib vci_multi_timer + - the SocLib vci_dma + - The SoCLib vci_icu + - The SoCLib vci_gcd + - The SoCLib vci_frame_buffer + - The SoCLib vci_block_device +****************************************************************************************/ + +#ifndef _DRIVERS_H_ +#define _DRIVERS_H_ + +#include "tty.h" +#include "dma.h" +#include "gcd.h" +#include "timer.h" +#include "icu.h" +#include "block_device.h" + +typedef unsigned int size_t; + +// global variables defined in giet.s + +extern unsigned int _task_context_array[]; +extern unsigned int _current_task_array[]; +extern unsigned int _task_number_array[]; + +// function defined in giet.s + +void _ctx_switch(); + +// global variables defined in drivers.c + +extern int volatile _dma_status[]; +extern int volatile _dma_busy[]; + +extern int volatile _ioc_lock; +extern int volatile _ioc_done; +extern int volatile _ioc_status; + +extern char volatile _tty_get_buf[]; +extern int volatile _tty_get_full[]; + +extern char volatile _tty_put_buf[]; +extern int volatile _tty_put_full[]; + +// functions defined in drivers.c + +unsigned int _procid(); +unsigned int _proctime(); +unsigned int _procnumber(); + +unsigned int _segment_increment(); + +void _itoa_dec(unsigned int val, char* buf); +void _itoa_hex(int val, char* buf); + +int _exit(); + +int _timer_write(size_t timer_index, size_t register_index, int value); +int _timer_read(size_t timer_index, size_t register_index, int* buffer); + +int _tty_write(char* buffer, int length); +int _tty_read(char* buffer, int length); + +int _io_write(size_t lba, void* buffer, size_t count); +int _io_read(size_t lba, void* buffer, size_t count); +int _io_completed(); + +int _icu_write(size_t register_index, int value); +int _icu_read(size_t register_index, int* buffer); + +int _gcd_write(size_t register_index, int value); +int _gcd_read(size_t register_index, int* buffer); + +int _locks_write(size_t lock_index); +int _locks_read(size_t lock_index); + +int _fb_sync_write(size_t offset, void* buffer, size_t length); +int _fb_sync_read(size_t offset, void* buffer, size_t length); + +int _fb_write(size_t offset, void* buffer, size_t length); +int _fb_read(size_t offset, void* buffer, size_t length); +int _fb_completed(); + +int _barrier_init(size_t index, size_t count); +int _barrier_wait(size_t index); + +#endif + +// Local Variables: +// tab-width: 4; +// c-basic-offset: 4; +// c-file-offsets:((innamespace . 0)(inline-open . 0)); +// indent-tabs-mode: nil; +// End: +// +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 + Index: trunk/softs/giet_tsar/gcd.h =================================================================== --- trunk/softs/giet_tsar/gcd.h (revision 620) +++ trunk/softs/giet_tsar/gcd.h (revision 620) @@ -0,0 +1,23 @@ +#ifndef GCD_REGS_H +#define GCD_REGS_H + +enum SoclibLcdRegisters { + GCD_OPA = 0, + GCD_OPB = 1, + GCD_START = 2, + GCD_STATUS = 3, + /**/ + GCD_SPAN = 4, +}; + +#endif + +// Local Variables: +// tab-width: 4; +// c-basic-offset: 4; +// c-file-offsets:((innamespace . 0)(inline-open . 0)); +// indent-tabs-mode: nil; +// End: +// +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 + Index: trunk/softs/giet_tsar/giet.s =================================================================== --- trunk/softs/giet_tsar/giet.s (revision 620) +++ trunk/softs/giet_tsar/giet.s (revision 620) @@ -0,0 +1,726 @@ +/********************************************************************************* +* File : giet.s +* Author : Franck Wajsburt & Alain Greiner & Joel Porquet +* Date : 2009 - 2010 +********************************************************************************** +* Interruption/Exception/Trap Handler for MIPS32 processor +* The base address of the segment containing this code +* MUST be 0x80000000, in order to have the entry point +* at address 0x80000180 !!! +* All messages are printed on the TTY defined by the processor ID. +********************************************************************************** +* History : +* 15/09/2009 : The GIET entry point has been modified to comply with +* the MIPS32 specification : 0x80000180 +* 5/10/2009 : The syscall handler has been modified to comply with the +* MIPS32 specification : the value stored in EPC register is the +* syscall instruction address => it must be incremented by 4 +* to obtain the return address. +* 15/10/2009 : The Interrupt handler has been modified to comply with the +* VCI_ICU specification : The IRQ index is obtained by a read +* to (icu_base_address + 16). +* 26/10/2009 : The interrupt handler has been modified to support +* multi-processors architectures with one ICU per processor. +* Finally, the mfc0 instruction uses now the select parameter +* to comply with the MIPS32 specification when accessing the +* processor_id (mtfc0 $x, $15, 1) +* 08/11/2009 : The syscall handler has been extended to support 32 values +* for the syscall index, and to enable interrupts when processing +* a system call. +* Five new syscalls have been introduced to access the frame buffer +* Three new syscalls have been introduced to access the block device +* The two syscalls associated to the DMA have been removed. +* 18/11/2009 : The syscall handler has been modified to save the SR in +* the stack before enabling interrupts. +* 15/03/2010 : replace the itoa_print assembler function by the itoa_hex() +* function defined in the syscalls.c file. +* 10/04/2010 : modify the interrupt handler to use the new ICU component +* supporting up to 8 output IRQs for 8 processors. +* The active IRQ index is obtained as ICU[32*PROC_ID+16]. +* 12/09/2010 : The ctx_switch functionhas been included in this file to +* simplify the compilation process. +* 25/09/2010 : add '.end' directive to end the _giet function +* and modify the 'sharp' comment character into the regular "slash +* asterix ... asterix slash" comment syntax +* 27/09/2010 : respect stack convention with 4 minimum slots before calling +* C functions +* 28/09/2010 : Save all the non-persistant registers in the int_handler +* 02/02/2011 : Introduce the "segment_increment" parameter in the interrupt +* handler to support clusterised multi-processing. +* Introducing the barrier_init() & barrier_wait() system calls. +* 04/04/2011 : introducing the system call proc_num() +* 12/04/2011 : modifying the _int_handler to support the XICU component in +* multi_clusters/multi-processors architectures: +* the XICU base address depends the cluster_id and the PRIO register +* address depends on the local_id. +**********************************************************************************/ + + .section .giet,"ax",@progbits + .align 2 + .global _interrupt_vector # makes interrupt_vector an external symbol + + .extern seg_icu_base + .extern seg_tty_base + .extern NB_CLUSTERS + .extern NB_PROCS + + .extern isr_default + + .extern _procid + .extern _proctime + .extern _tty_write + .extern _tty_read + .extern _tty_read_irq + .extern _timer_write + .extern _timer_read + .extern _icu_write + .extern _icu_read + .extern _gcd_write + .extern _gcd_read + .extern _locks_read + .extern _locks_write + .extern _exit + .extern _fb_sync_write + .extern _fb_sync_read + .extern _fb_write + .extern _fb_read + .extern _fb_completed + .extern _ioc_write + .extern _ioc_read + .extern _ioc_completed + .extern _itoa_hex + .extern _barrier_init + .extern _barrier_wait + + .ent _giet + +/*************************************************************** +* Cause Table (indexed by the Cause register) +***************************************************************/ +tab_causes: + .word _int_handler # 0000 : external interrupt + .word _cause_ukn # 0001 : undefined exception + .word _cause_ukn # 0010 : undefined exception + .word _cause_ukn # 0011 : undefined exception + .word _cause_adel # 0100 : illegal address read exception + .word _cause_ades # 0101 : illegal address write exception + .word _cause_ibe # 0110 : instruction bus error exception + .word _cause_dbe # 0111 : data bus error exception + .word _sys_handler # 1000 : system call + .word _cause_bp # 1001 : breakpoint exception + .word _cause_ri # 1010 : illegal codop exception + .word _cause_cpu # 1011 : illegal coprocessor access + .word _cause_ovf # 1100 : arithmetic overflow exception + .word _cause_ukn # 1101 : undefined exception + .word _cause_ukn # 1110 : undefined exception + .word _cause_ukn # 1111 : undefined exception + + .space 320 + +/*************************************************************** +* Entry point (at address 0x80000180) +***************************************************************/ +_giet: + mfc0 $27, $13 # Cause Register analysis + lui $26, 0x8000 # $26 <= tab_causes + andi $27, $27, 0x3c + addu $26, $26, $27 + lw $26, ($26) + jr $26 # Jump indexed by CR + .end _giet + +/**************************************************************** +* System Call Handler +* A system call is handled as a special function call. +* - $2 contains the system call index (< 16). +* - $3 is used to store the syscall address +* - $4, $5, $6, $7 contain the arguments values. +* - The return address (EPC) iand the SR are saved in the stack. +* - Interrupts are enabled before branching to the syscall. +* - All syscalls must return to the syscall handler. +* - $2, $3, $4, $5, $6, $7 as well as $26 & $27 can be modified. +* +* In case of undefined system call, an error message displays +* the value of EPC on the TTY corresponding to the processor, +* and the user program is killed. +****************************************************************/ +_sys_handler: + addiu $29, $29, -24 # 2 slots for SR&EPC, 4 slots for args passing + mfc0 $26, $12 # load SR + sw $26, 16($29) # save it in the stack + mfc0 $27, $14 # load EPC + addiu $27, $27, 4 # increment EPC for return address + sw $27, 20($29) # save it in the stack + + andi $26, $2, 0x1F # $26 <= syscall index (i < 32) + sll $26, $26, 2 # $26 <= index * 4 + la $27, tab_syscalls # $27 <= &tab_syscalls[0] + addu $27, $27, $26 # $27 <= &tab_syscalls[i] + lw $3, 0($27) # $3 <= syscall address + + li $27, 0xFFFFFFED # Mask for UM & EXL bits + mfc0 $26, $12 # $26 <= SR + and $26, $26, $27 # UM = 0 / EXL = 0 + mtc0 $26, $12 # interrupt enabled + jalr $3 # jump to the proper syscall + mtc0 $0, $12 # interrupt disbled + + lw $26, 16($29) # load SR from stack + mtc0 $26, $12 # restore SR + lw $26, 20($29) # load EPC from stack + mtc0 $26, $14 # restore EPC + addiu $29, $29, 24 # restore stack pointer + eret # exit GIET + +_sys_ukn: # undefined system call + la $4, msg_uknsyscall # $4 <= message address + li $5, 36 # $5 <= message length + jal _tty_write # print unknown message + + la $4, msg_epc # $4 <= message address + li $5, 8 # $5 <= message length + jal _tty_write # print EPC message + + mfc0 $4, $14 # $4 <= EPC + la $5, itoa_buffer # $5 <= buffer address + addiu $5, $5, 2 # skip the 0x prefix + jal _itoa_hex # fill the buffer + + la $4, itoa_buffer # $4 <= buffer address + li $5, 10 # $5 <= buffer length + jal _tty_write # print EPC value + + j _exit # end of program + +itoa_buffer: .ascii "0x00000000" + + .align 2 + +/**************************************************************** +* System Call Table (indexed by syscall index) +****************************************************************/ +tab_syscalls: + .word _procid # 0x00 + .word _proctime # 0x01 + .word _tty_write # 0x02 + .word _tty_read # 0x03 + .word _timer_write # 0x04 + .word _timer_read # 0x05 + .word _gcd_write # 0x06 + .word _gcd_read # 0x07 + .word _icu_write # 0x08 + .word _icu_read # 0x09 + .word _tty_read_irq # 0x0A + .word _sys_ukn # 0x0B + .word _locks_write # 0x0C + .word _locks_read # 0x0D + .word _exit # 0x0E + .word _procnumber # 0x0F + .word _fb_sync_write # 0x10 + .word _fb_sync_read # 0x11 + .word _fb_write # 0x12 + .word _fb_read # 0x13 + .word _fb_completed # 0x14 + .word _ioc_write # 0x15 + .word _ioc_read # 0x16 + .word _ioc_completed # 0x17 + .word _barrier_init # 0x18 + .word _barrier_wait # 0x19 + .word _sys_ukn # 0x1A + .word _sys_ukn # 0x1B + .word _sys_ukn # 0x1C + .word _sys_ukn # 0x1D + .word _sys_ukn # 0x1E + .word _sys_ukn # 0x1F + +/****************************************************************** +* Interrupt Handler +* This simple interrupt handler cannot be interrupted. +* It uses an external ICU component (Interrupt Controler Unit) +* that concentrates up to 32 interrupts lines to a single IRQ +* line that can be connected to any of the 6 MIPS IT inputs. +* This component returns the highest priority active interrupt index +* (smaller indexes have the highest priority). +* +* In case of a multi-clusters architecture, it exist one ICU +* per cluster. The base address of the ICU segment depends on both +* the cluster_id and the proc_id: +* - icu_base_address = seg_icu_base + (32 * local_id) + +* (cluster_increment * cluster _id) +* - cluster_id = proc_id / NB_PROCS +* - local_id = proc_id % NB_PROCS +* - cluster_increment = 4G / NB_CLUSTERS +* +* The interrupt handler reads the XICU PRIO register, +* using the offset 16. +* This component returns the highest priority interrupt index +* (smaller indexes have the highest priority). +* Any value larger than 31 means "no active interrupt", and +* the default ISR (that does nothing) is executed. +* The interrupt vector (32 ISR addresses array stored at +* _interrupt_vector address) is initialised with the default +* ISR address. The actual ISR addresses are supposed to be written +* in the interrupt vector array by the boot code. +* All non persistant registers, such as $1 to $15, and $24 to $25, +* as well as register $31 and EPC, are saved in the interrupted +* program stack, before calling the Interrupt Service Routine. +* These registers can be used by the ISR code. +*******************************************************************/ +_int_handler: + addiu $29, $29, -23*4 # stack space reservation + .set noat + sw $1, 4*4($29) # save $1 + .set at + sw $2, 4*5($29) # save $2 + sw $3, 4*6($29) # save $3 + sw $4, 4*7($29) # save $4 + sw $5, 4*8($29) # save $5 + sw $6, 4*9($29) # save $6 + sw $7, 4*10($29) # save $7 + sw $8, 4*11($29) # save $8 + sw $9, 4*12($29) # save $9 + sw $10, 4*13($29) # save $10 + sw $11, 4*14($29) # save $11 + sw $12, 4*15($29) # save $12 + sw $13, 4*16($29) # save $13 + sw $14, 4*17($29) # save $14 + sw $15, 4*18($29) # save $15 + sw $24, 4*19($29) # save $24 + sw $25, 4*20($29) # save $25 + sw $31, 4*21($29) # save $31 + mfc0 $27, $14 + sw $27, 4*22($29) # save EPC + + # XICU PRIO register address computation (depending on cluster_id & local_id) + mfc0 $10, $15, 1 # $10 <= proc_id + andi $10, $10, 0x3FF # at most 1024 processors + la $11, NB_PROCS # $11 <= NB_PROCS + divu $10, $11 + mflo $12 # $12 <= cluster_id + mfhi $13 # $13 <= local_id + la $11, NB_CLUSTERS # $11 <= NB_CLUSTERS + li $14, 0x80000000 + divu $14, $11 + mflo $15 + sll $15, $15, 1 # $15 <= cluster_increment = 4G / NB_CLUSTERS + multu $15, $12 + mflo $6 # $6 <= cluster_increment * cluster_id + li $7, 0b011110000000 # $7 <= PRIO offset + sll $8, $13, 2 # $8 <= local_id*4 + addu $9, $7, $8 # $9 <= PRIO offset + local_id*4 + la $27, seg_icu_base + addu $26, $9, $27 # $26 <= seg_icu_base + PRIO offset + local_id*4 + addu $26, $26, $6 # $26 <= seg_icu_base + increment*cluster_id + PRIO offset + local_id*4 + + # XICU access and interrupt vector access + lw $26, ($26) # $26 <= PRIO register value + andi $27, $26, 0x2 # test bit HWI active + beq $27, $0, restore # do nothing if no active IRQ + srl $26, $26, 14 # $26 <= $26 >> 14 + andi $26, $26, 0x7C # $26 <= interrupt_index * 4 + la $27, _interrupt_vector + addu $26, $26, $27 + lw $26, ($26) # read ISR address + jalr $26 # call ISR +restore: + .set noat + lw $1, 4*4($29) # restore $1 + .set at + lw $2, 4*5($29) # restore $2 + lw $3, 4*6($29) # restore $3 + lw $4, 4*7($29) # restore $4 + lw $5, 4*8($29) # restore $5 + lw $6, 4*9($29) # restore $6 + lw $7, 4*10($29) # restore $7 + lw $8, 4*11($29) # restore $8 + lw $9, 4*12($29) # restore $9 + lw $10, 4*13($29) # restore $10 + lw $11, 4*14($29) # restore $11 + lw $12, 4*15($29) # restore $12 + lw $13, 4*16($29) # restore $13 + lw $14, 4*17($29) # restore $14 + lw $15, 4*18($29) # restore $15 + lw $24, 4*19($29) # restore $24 + lw $25, 4*20($29) # restore $25 + lw $31, 4*21($29) # restore $31 + lw $27, 4*22($29) # return address (EPC) + addiu $29, $29, 23*4 # restore stack pointer + mtc0 $27, $14 # restore EPC + eret # exit GIET + +/* The default ISR is called when no specific ISR has been installed in the + interrupt vector. It simply displays a message on TTY 0. */ + +isr_default: + addiu $29, $29, -20 # get space in stack + sw $31, 16($29) # to save the return address + la $4, msg_default # $4 <= string address + addi $5, $0, 36 # $5 <= string length + jal _tty_write # print + lw $31, 16($29) # restore return address + addiu $29, $29, 20 # free space + jr $31 # returns to interrupt handler + +/***************************************************** + Interrupt Vector Table (indexed by interrupt index) + 32 words corresponding to 32 ISR addresses +******************************************************/ +_interrupt_vector: + .word isr_default # ISR 0 + .word isr_default # ISR 1 + .word isr_default # ISR 2 + .word isr_default # ISR 3 + .word isr_default # ISR 4 + .word isr_default # ISR 5 + .word isr_default # ISR 6 + .word isr_default # ISR 7 + .word isr_default # ISR 8 + .word isr_default # ISR 9 + .word isr_default # ISR 10 + .word isr_default # ISR 11 + .word isr_default # ISR 12 + .word isr_default # ISR 13 + .word isr_default # ISR 14 + .word isr_default # ISR 15 + .word isr_default # ISR 16 + .word isr_default # ISR 17 + .word isr_default # ISR 18 + .word isr_default # ISR 19 + .word isr_default # ISR 20 + .word isr_default # ISR 21 + .word isr_default # ISR 22 + .word isr_default # ISR 23 + .word isr_default # ISR 24 + .word isr_default # ISR 25 + .word isr_default # ISR 26 + .word isr_default # ISR 27 + .word isr_default # ISR 28 + .word isr_default # ISR 29 + .word isr_default # ISR 30 + .word isr_default # ISR 31 + +/*********************************************************** +* Exception Handler +* Same code for all fatal exceptions : +* Print the exception type and the values of EPC & BAR +* on the TTY correspondintg to the processor PROCID, +* and the user program is killed. +***********************************************************/ +_cause_bp: +_cause_ukn: +_cause_ri: +_cause_ovf: +_cause_adel: +_cause_ades: +_cause_ibe: +_cause_dbe: +_cause_cpu: + mfc0 $26, $13 # $26 <= CR + andi $26, $26, 0x3C # $26 <= _cause_index * 4 + la $27, mess_causes # mess_cause table base address + addu $27, $26, $27 # pointer on the message base address + + lw $4, ($27) # $4 <= message address + li $5, 36 # $5 <= message length + jal _tty_write # print message cause + + la $4, msg_epc # $4 <= message address + li $5, 8 # $5 <= message length + jal _tty_write # print message EPC + + mfc0 $4, $14 # $4 <= EPC value + la $5, itoa_buffer # $5 <= buffer address + addiu $5, $5, 2 # skip 0x prefix + jal _itoa_hex # fill buffer + + la $4, itoa_buffer # $4 <= buffer address + li $5, 10 # $5 <= buffer length + jal _tty_write # print EPC value + + la $4, msg_bar # $4 <= mesage address + li $5, 8 # $5 <= message length + jal _tty_write # print message BAR + + mfc0 $4, $8 # $4 <= BAR value + la $5, itoa_buffer # $5 <= buffer address + addiu $5, $5, 2 # skip 0x prefix + jal _itoa_hex # fill buffer + + la $4, itoa_buffer # $4 <= mesage address + li $5, 10 # $5 <= message length + jal _tty_write # print BAR value + + j _exit # end program + +# Exceptions Messages table (indexed by CAUSE) +mess_causes: + .word msg_ukncause + .word msg_ukncause + .word msg_ukncause + .word msg_ukncause + .word msg_adel + .word msg_ades + .word msg_ibe + .word msg_dbe + .word msg_ukncause + .word msg_bp + .word msg_ri + .word msg_cpu + .word msg_ovf + .word msg_ukncause + .word msg_ukncause + .word msg_ukncause + +/***************************************************************** +* All messages +* Messages length are fixed : 8 or 36 characters... +*****************************************************************/ +msg_bar: .asciiz "\nBAR = " +msg_epc: .asciiz "\nEPC = " +msg_default: .asciiz "\n\n !!! Default ISR !!! \n" +msg_uknsyscall: .asciiz "\n\n !!! Undefined System Call !!! \n" +msg_ukncause: .asciiz "\n\nException : strange unknown cause\n" +msg_adel: .asciiz "\n\nException : illegal read address \n" +msg_ades: .asciiz "\n\nException : illegal write address\n" +msg_ibe: .asciiz "\n\nException : inst bus error \n" +msg_dbe: .asciiz "\n\nException : data bus error \n" +msg_bp: .asciiz "\n\nException : breakpoint \n" +msg_ri: .asciiz "\n\nException : reserved instruction \n" +msg_ovf: .asciiz "\n\nException : arithmetic overflow \n" +msg_cpu: .asciiz "\n\nException : illegal coproc access\n" + .align 2 + + +/*************************************************************************** +* _ctx_switch +* The _ctx_switch function performs a context switch between the +* current task and another task. +* It can be used in a multi-processor architecture, with the assumption +* that the tasks are statically allocated to processors. +* The max number of processorsi is 8, and the max number of tasks is 4. +* The scheduling policy is very simple : For each processor, the task index +* is incremented, modulo the number of tasks allocated to the processor. +* +* It has no argument, and no return value. +* +* It uses three global variables: +* - _current_task_array : an array of 8 task index: +* (index of the task actually running on each processor) +* - _task_number_array : an array of 8 numbers: +* (the number of tasks allocated to each processor) +* - _task_context_array : an array of 32 task contexts: +* (at most 8 processors / each processor can run up to 4 tasks) +* A task context is an array of 64 words = 256 bytes. +* It is indexed by m = (proc_id*4 + task_id) +* It contains copies of the processor registers. +* As much as possible a register is stored at the index defined by its number +* ( for example, $8 is saved in ctx[8]). +* The exception are : +* $0 is not saved since always 0 +* $26, $27 are not saved since not used by the task +* +* 0*4(ctx) SR 8*4(ctx) $8 16*4(ctx) $16 24*4(ctx) $24 32*4(ctx) EPC +* 1*4(ctx) $1 9*4(ctx) $9 17*4(ctx) $17 25*4(ctx) $25 33*4(ctx) CR +* 2*4(ctx) $2 10*4(ctx) $10 18*4(ctx) $18 26*4(ctx) LO 34*4(ctx) reserved +* 3*4(ctx) $3 11*4(ctx) $11 19*4(ctx) $19 27*4(ctx) HI 35*4(ctx) reserved +* 4*4(ctx) $4 12*4(ctx) $12 20*4(ctx) $20 28*4(ctx) $28 36*4(ctx) reserved +* 5*4(ctx) $5 13*4(ctx) $13 21*4(ctx) $21 29*4(ctx) $29 37*4(ctx) reserved +* 6*4(ctx) $6 14*4(ctx) $14 22*4(ctx) $22 30*4(ctx) $30 38*4(ctx) reserved +* 7*4(ctx) $7 15*4(ctx) $15 23*4(ctx) $23 31*4(ctx) $31 39*4(ctx) reserved +* +* The return address contained in $31 is saved in the _current task context +* (in the ctx[31] slot), and the function actually returns to the address contained +* in the ctx[31] slot of the new task context. +* +* Caution : This function is intended to be used with periodic interrupts. +* It can be directly called by the OS, but interrupts must be disabled before calling. +***************************************************************************************/ + + .section .ksave + + .global _task_context_array # initialised in reset.s + .global _current_task_array # initialised in reset.s + .global _task_number_array # initialised in reset.s + +_task_context_array: # 32 contexts : indexed by (proc_id*4 + task_id) + .space 8192 + +_current_task_array: # 8 words : indexed by the proc_id + .word 0 # _current_task_array[0] <= 0 + .word 0 # _current_task_array[1] <= 0 + .word 0 # _current_task_array[2] <= 0 + .word 0 # _current_task_array[3] <= 0 + .word 0 # _current_task_array[4] <= 0 + .word 0 # _current_task_array[5] <= 0 + .word 0 # _current_task_array[6] <= 0 + .word 0 # _current_task_array[7] <= 0 + +_task_number_array: # 8 words : indexed by the proc_id + .word 1 # _task_number_array[0] <= 1 + .word 1 # _task_number_array[1] <= 1 + .word 1 # _task_number_array[2] <= 1 + .word 1 # _task_number_array[3] <= 1 + .word 1 # _task_number_array[4] <= 1 + .word 1 # _task_number_array[5] <= 1 + .word 1 # _task_number_array[6] <= 1 + .word 1 # _task_number_array[7] <= 1 + +/***************************************************************************************/ + + .section .switch + + .global _ctx_switch # makes it an external symbol + .align 2 + +_ctx_switch: + + # test if more than one task on the processor + + mfc0 $26, $15, 1 + andi $26, $26, 0x7 # $26 <= proc_id + sll $26, $26, 2 # $26 <= 4*proc_id + la $27, _task_number_array # $27 <= base address of _task_number_array + addu $27, $27, $26 # $27 <= _task_number_array + 4*proc_id + lw $27, ($27) # $27 <= task number + addi $26, $27, -1 # $26 <= _task_number - 1 + bnez $26, do_it # 0 if only one task + jr $31 # return + + # save _current task context + +do_it: + mfc0 $26, $15, 1 + andi $26, $26, 0x7 # $26 <= proc_id + sll $26, $26, 2 # $26 <= 4*proc_id + la $27, _current_task_array # $27 <= base address of _current_task_array + addu $27, $27, $26 # $27 <= _current_task_array + 4*proc_id + lw $26, ($27) # $26 <= current task index + sll $26, $26, 8 # $26 <= 256*task_id + la $27, _task_context_array # $27 <= base address of context array + addu $27, $27, $26 # $27 <= _task_context_array + 256*task_id + mfc0 $26, $15, 1 + andi $26, $26, 0x7 # $26 <= proc_id + sll $26, $26, 10 # $26 <= 1024*proc_id + addu $27, $27, $26 # $27 <= taxk_context_array + 256*(proc_id*4 + task_id) + + mfc0 $26, $12 # $26 <= SR + sw $26, 0*4($27) # ctx[0] <= SR + .set noat + sw $1, 1*4($27) # ctx[1] <= $1 + .set at + sw $2, 2*4($27) # ctx[2] <= $2 + sw $3, 3*4($27) # ctx[3] <= $3 + sw $4, 4*4($27) # ctx[4] <= $4 + sw $5, 5*4($27) # ctx[5] <= $5 + sw $6, 6*4($27) # ctx[6] <= $6 + sw $7, 7*4($27) # ctx[7] <= $7 + sw $8, 8*4($27) # ctx[8] <= $8 + sw $9, 9*4($27) # ctx[9] <= $9 + sw $10, 10*4($27) # ctx[10] <= $10 + sw $11, 11*4($27) # ctx[11] <= $11 + sw $12, 12*4($27) # ctx[12] <= $12 + sw $13, 13*4($27) # ctx[13] <= $13 + sw $14, 14*4($27) # ctx[14] <= $14 + sw $15, 15*4($27) # ctx[15] <= $15 + sw $16, 16*4($27) # ctx[16] <= $16 + sw $17, 17*4($27) # ctx[17] <= $17 + sw $18, 18*4($27) # ctx[18] <= $18 + sw $19, 19*4($27) # ctx[19] <= $19 + sw $20, 20*4($27) # ctx[20] <= $20 + sw $21, 21*4($27) # ctx[21] <= $21 + sw $22, 22*4($27) # ctx[22] <= $22 + sw $23, 23*4($27) # ctx[23] <= $23 + sw $24, 24*4($27) # ctx[24] <= $24 + sw $25, 25*4($27) # ctx[25] <= $25 + mflo $26 + sw $26, 26*4($27) # ctx[26] <= LO + mfhi $26 + sw $26, 27*4($27) # ctx[27] <= H1 + sw $28, 28*4($27) # ctx[28] <= $28 + sw $29, 29*4($27) # ctx[29] <= $29 + sw $30, 30*4($27) # ctx[30] <= $30 + sw $31, 31*4($27) # ctx[31] <= $31 + mfc0 $26, $14 + sw $26, 32*4($27) # ctx[32] <= EPC + mfc0 $26, $13 + sw $26, 33*4($27) # ctx[33] <= CR + + # select the new task + + mfc0 $15, $15, 1 + andi $15, $15, 0x7 # $15 <= proc_id + sll $16, $15, 2 # $16 <= 4*proc_id + la $17, _current_task_array # $17 <= base address of _current_task_array + addu $17, $17, $16 # $17 <= _current_task_array + 4*proc_id + lw $18, ($17) # $18 <= _current task index + la $19, _task_number_array # $19 <= base address of _task_number_array + addu $19, $19, $16 # $19 <= _task_number_array + 4*proc_id + lw $20, ($19) # $20 <= max = number of tasks + addiu $18, $18, 1 # $18 <= new task index + sub $2, $18, $20 # test modulo max + bne $2, $0, no_wrap + add $18, $0, $0 # $18 <= new task index +no_wrap: + sw $18, ($17) # update _current_task_array + + # restore next task context + + sll $19, $18, 8 # $19 <= 256*task_id + la $27, _task_context_array # $27 <= base address of context array + addu $27, $27, $19 # $27 <= _task_context_array + 256*task_id + sll $19, $15, 10 # $19 <= 1024*proc_id + addu $27, $27, $19 # $27 <= _task_context_array + 256*(proc_id*4 + task_id) + + lw $26, 0*4($27) + mtc0 $26, $12 # restore SR + .set noat + lw $1, 1*4($27) # restore $1 + .set at + lw $2, 2*4($27) # restore $2 + lw $3, 3*4($27) # restore $3 + lw $4, 4*4($27) # restore $4 + lw $5, 5*4($27) # restore $5 + lw $6, 6*4($27) # restore $6 + lw $7, 7*4($27) # restore $7 + lw $8, 8*4($27) # restore $8 + lw $9, 9*4($27) # restore $9 + lw $10, 10*4($27) # restore $10 + lw $11, 11*4($27) # restore $11 + lw $12, 12*4($27) # restore $12 + lw $13, 13*4($27) # restore $13 + lw $14, 14*4($27) # restore $14 + lw $15, 15*4($27) # restore $15 + lw $16, 16*4($27) # restore $16 + lw $17, 17*4($27) # restore $17 + lw $18, 18*4($27) # restore $18 + lw $19, 19*4($27) # restore $19 + lw $20, 20*4($27) # restore $20 + lw $21, 21*4($27) # restore $21 + lw $22, 22*4($27) # restore $22 + lw $23, 23*4($27) # restore $23 + lw $24, 24*4($27) # restore $24 + lw $25, 25*4($27) # restore $25 + lw $26, 26*4($27) + mtlo $26 # restore LO + lw $26, 27*4($27) + mthi $26 # restore HI + lw $28, 28*4($27) # restore $28 + lw $29, 29*4($27) # restore $29 + lw $30, 30*4($27) # restore $30 + lw $31, 31*4($27) # restore $31 + lw $26, 32*4($27) + mtc0 $26, $14 # restore EPC + lw $26, 33*4($27) + mtc0 $26, $13 # restore CR + + jr $31 # returns to caller + +/* Local Variables: + tab-width: 4; + c-basic-offset: 4; + c-file-offsets:((innamespace . 0)(inline-open . 0)); + indent-tabs-mode: nil; + End: */ + +/* vim: set filetype=asm expandtab shiftwidth=4 tabstop=4 softtabstop=4: */ + Index: trunk/softs/giet_tsar/icu.h =================================================================== --- trunk/softs/giet_tsar/icu.h (revision 620) +++ trunk/softs/giet_tsar/icu.h (revision 620) @@ -0,0 +1,24 @@ +#ifndef ICU_REGS_H +#define ICU_REGS_H + +enum SoclibPicRegisters { + ICU_INT = 0, + ICU_MASK = 1, + ICU_MASK_SET = 2, + ICU_MASK_CLEAR = 3, + ICU_IT_VECTOR = 4, + /***/ + ICU_SPAN = 8, +}; + +#endif + +// Local Variables: +// tab-width: 4; +// c-basic-offset: 4; +// c-file-offsets:((innamespace . 0)(inline-open . 0)); +// indent-tabs-mode: nil; +// End: +// +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 + Index: trunk/softs/giet_tsar/isr.c =================================================================== --- trunk/softs/giet_tsar/isr.c (revision 620) +++ trunk/softs/giet_tsar/isr.c (revision 620) @@ -0,0 +1,186 @@ +/************************************************************************************* + File : isr.c + Authors : Alain Greiner + Date : april 2011 + + These routines must be "intalled" by the boot code in the + interrupt vector, depending on the system architecture. +*************************************************************************************/ + +#include "isr.h" +#include "drivers.h" + +#define in_isr __attribute__((section (".isr"))) + +struct plaf; + +extern struct plaf seg_dma_base; +extern struct plaf seg_ioc_base; +extern struct plaf seg_timer_base; +extern struct plaf seg_tty_base; + +extern struct plaf NB_TIMERS; +extern struct plaf NB_TASKS; + +////////////////////////////////////////////////////////////////////////////////////// +// _isr_dma +// Each processor controls its own private DMA. +// It acknowledge the IRQ using the dma base address depending on the proc_id +// as computed by the _segment_increment() function, writes the transfer +// status in the _dma_status[pid] variable, and resets the _dma_busy[pid] +// synchrnisation variable to signal completion. +// Both variables are defined in the drivers.c file. +///////////////////////////////////////////////////////////////////////////////////// +in_isr void _isr_dma() +{ + int* dma_address; + unsigned int base = (unsigned int)&seg_dma_base; + unsigned int increment = _segment_increment(DMA_SPAN*4); + size_t pid = _procid(); + + dma_address = (int*)(base + increment); + + _dma_status[pid] = dma_address[DMA_LEN]; // save status + _dma_busy[pid] = 0; // release DMA + dma_address[DMA_RESET] = 0; // reset IRQ +} +////////////////////////////////////////////////////////////////////////////////////// +// _isr_ioc +// There is only one IOC controler shared by all tasks. +// It acknowledge the IRQ using the ioc base address, save the status, +// and set the _ioc_done variable to signal completion. +// This variable is defined in the drivers.c file. +////////////////////////////////////////////////////////////////////////////////////// +in_isr void _isr_ioc() +{ + int* ioc_address = (int*)&seg_ioc_base; + + _ioc_status = ioc_address[BLOCK_DEVICE_STATUS]; // save status & reset IRQ + _ioc_done = 1; // signals completion +} +////////////////////////////////////////////////////////////////////////////////////// +// _isr_timer* (* = 0,1,2,3) +// A single processor can use up to 4 independant timers. +// These 4 ISRs handle up to 4 IRQs generated by 4 independant timers, +// connected to a single processor. +// It acknowledge the IRQ using the timer base address depending +// on both the proc_id and the timer_id (0,1,2,3). +// It displays a message on TTY[proc_id,task_id]. +////////////////////////////////////////////////////////////////////////////////////// +in_isr void _isr_timer_indexed(size_t timer_id) +{ + int* timer_address; + size_t ntimers = (size_t)&NB_TIMERS; + unsigned int base = (unsigned int)&seg_timer_base; + unsigned int increment = _segment_increment(ntimers*TIMER_SPAN*4); + int date = (int)_proctime(); + char buf[10]; + + timer_address = (int*)(base + increment + timer_id*TIMER_SPAN*4); + + timer_address[TIMER_RESETIRQ] = 0; // reset IRQ + + _itoa_dec(date, buf); // print message + _tty_write("\n!!! interrupt timer0 received at cycle ", 40); + _tty_write(buf, 10); + _tty_write("\n\n", 2); +} +in_isr void _isr_timer() +{ + _isr_timer_indexed(0); +} +in_isr void _isr_timer0() +{ + _isr_timer_indexed(0); +} +in_isr void _isr_timer1() +{ + _isr_timer_indexed(1); +} +in_isr void _isr_timer2() +{ + _isr_timer_indexed(2); +} +in_isr void _isr_timer3() +{ + _isr_timer_indexed(3); +} +////////////////////////////////////////////////////////////////////////////////////// +// _isr_tty_get_task* (* = 0,1,2,3) +// A single processor can run up to 4 tasks in pseudo-parallelismr, +// and each task has is own private terminal. +// These 4 ISRs handle up to 4 IRQs associate to 4 independant terminals +// connected to a single processor. +// It acknowledge the IRQ using the terminal basee address depending +// on both the proc_id and the task_id (0,1,2,3). +// There is one communication buffer _tty_get_buf[tty_id] per terminal. +// protected by a set/reset variable _tty_get_full[tty_id]. +// The _tty_get_full[tty_id] synchronisation variable is set +// by the ISR, and reset by the OS. +// Both variables are defined in the drivers.c file. +// To access these buffers, the terminal index is computed as +// tty_id = proc_id*ntasks + task_id +// A character is lost if the buffer is full when the ISR is executed. +////////////////////////////////////////////////////////////////////////////////////// +in_isr void _isr_tty_get_indexed(size_t task_id) +{ + char* tty_address; + size_t ntasks = (size_t)&NB_TASKS; + size_t tty_id = _procid()*ntasks + task_id; + unsigned int base = (unsigned int)&seg_tty_base; + unsigned int increment = _segment_increment(ntasks*TTY_SPAN*4); + + tty_address = (char*)(base + increment + task_id*TTY_SPAN*4); + + _tty_get_buf[tty_id] = tty_address[TTY_READ*4]; // save character and reset IRQ + _tty_get_full[tty_id] = 1; // signals character available +} +in_isr void _isr_tty_get() +{ + _isr_tty_get_indexed(0); +} +in_isr void _isr_tty_get_task0() +{ + _isr_tty_get_indexed(0); +} +in_isr void _isr_tty_get_task1() +{ + _isr_tty_get_indexed(1); +} +in_isr void _isr_tty_get_task2() +{ + _isr_tty_get_indexed(2); +} +in_isr void _isr_tty_get_task3() +{ + _isr_tty_get_indexed(3); +} +////////////////////////////////////////////////////////////////////////////////////// +// _isr_switch +// This ISR is in charge of context switch. +// It handles up to 4 IRQs, corresponding to 4 different processors. +// If the processor uses several timers, the context switch is driven +// by the IRQ associated to timer0. +// It acknowledges the IRQ on TIMER[proc_id] and calls the _ctx_switch() function. +////////////////////////////////////////////////////////////////////////////////////// +in_isr void _isr_switch() +{ + int* timer_address; + unsigned int base = (unsigned int)&seg_timer_base; + unsigned int increment = _segment_increment(TIMER_SPAN*4); + + timer_address = (int*)(base + increment); + + timer_address[TIMER_RESETIRQ] = 0; // reset IRQ + _ctx_switch(); +} + +/* Local Variables: + tab-width: 4; + c-basic-offset: 4; + c-file-offsets:((innamespace . 0)(inline-open . 0)); + indent-tabs-mode: nil; + End: */ + +/* vim: set filetype=c expandtab shiftwidth=4 tabstop=4 softtabstop=4: */ + Index: trunk/softs/giet_tsar/isr.h =================================================================== --- trunk/softs/giet_tsar/isr.h (revision 620) +++ trunk/softs/giet_tsar/isr.h (revision 620) @@ -0,0 +1,24 @@ +/************************************************************************************** + File : isr.h + Written by Alain Greiner + Date : April 2011 + + The Interrupt Service Routine (ISR) supported by the GIET are: +**************************************************************************************/ + +void _isr_dma(); + +void _isr_ioc(); + +void _isr_timer0(); +void _isr_timer1(); +void _isr_timer2(); +void _isr_timer3(); + +void _isr_tty_get(); +void _isr_tty_get_task0(); +void _isr_tty_get_task1(); +void _isr_tty_get_task2(); +void _isr_tty_get_task3(); + +void _isr_switch(); Index: trunk/softs/giet_tsar/reset.s =================================================================== --- trunk/softs/giet_tsar/reset.s (revision 620) +++ trunk/softs/giet_tsar/reset.s (revision 620) @@ -0,0 +1,135 @@ +################################################################################# +# File : reset.s +# Author : Alain Greiner +# Date : 15/04/2011 +################################################################################# +# This is a boot code for a generic multi-clusters / multi-processors +# TSAR architecture (up to 256 clusters / up to 4 processors per cluster). +# There is one XICU, one TTY, one DMA and one stack segment per cluster. +# segment base adresses = base + cluster_segment_increment*cluster_id +# - Each processor initializes the stack pointer ($29) depending on pid. +# - Only processor 0 initializes the Interrupt vector (TTY, DMA & IOC). +# - Each processor initialises its private ICU mask register. +# - Each processor initializes the Status Register (SR) +# - Each processor initializes the EPC register, and jumps to the main +# address in kernel mode... +################################################################################# + + .section .reset,"ax",@progbits + + .extern seg_stack_base + .extern seg_icu_base + .extern _interrupt_vector + .extern _isr_tty_get + .extern _isr_dma + .extern _isr_ioc + + .extern NB_PROCS + .extern NB_CLUSTERS + + .globl reset # makes reset an external symbol + .ent reset + .align 2 + +reset: + .set noreorder + +# computes proc_id, local_id, cluster_id, and cluster_increment + mfc0 $26, $15, 1 + andi $10, $26, 0x3FF # $10 <= proc_id (at most 1024 processors) + la $26, NB_PROCS # $26 <= number of processors per cluster + divu $10, $26 + mfhi $11 # $11 <= local_id = proc_id % NB_PROCS + mflo $12 # $12 <= cluster_id = proc_id / NB_PROCS + la $26, NB_CLUSTERS + li $13, 0x80000000 + divu $13, $26 + mflo $14 + sll $14, 1 # $14 <= cluster_increment = 4G / NB_CLUSTERS + mult $14, $12 + mflo $13 # $13 <= cluster_id * cluster_increment + +# initializes stack pointer depending on both the local_id and the cluster_id + la $27, seg_stack_base + addu $27, $27, $13 # $27 <= seg_stack_base + cluster_id * increment + li $26, 0x10000 # $26 <= 64K + addi $25, $11, 1 # $25 <= local_id + 1 + mult $25, $26 + mflo $24 # $24 <= 64K * (local_id+1) + addu $29, $27, $24 # $29 <= seg_stack_base + (cluster_id*increment) + (local_id+1)*64K + +# in each cluster, each processor initializes its private XICU mask register +# in each cluster, the ICU base address depends on the cluster_id + la $20, seg_icu_base + addu $20, $20, $13 # $20 <= seg_icu_base + cluster_id*cluster_increment + la $21, _reset_switch + sll $22, $11, 2 # $22 <= local_id*4 + addu $23, $21, $22 # $23 <= &_reset_switch[local_id*4] + lw $24, 0($23) + jr $24 + nop +_reset_proc0: + li $13, 0b010010000000 # offset for MSK_HWI_ENABLE & proc[0] + addu $13, $20, $13 + li $27, 0x111 # TTY[0] DMA[0] IOC + sw $27, 0($13) # MASK[0] + j _reset_itvector +_reset_proc1: + li $13, 0b010010000100 # offset for MSK_HWI_ENABLE & proc[1] + addu $13, $20, $13 + li $27, 0x022 # TTY[1] DMA[1] + sw $27, 0($13) # MASK[1] + j _reset_itvector +_reset_proc2: + li $13, 0b010010001000 # offset for MSK_HWI_ENABLE & proc[2] + addu $13, $20, $13 + li $27, 0x044 # TTY[2] DMA[2] + sw $27, 0($13) # MASK[2] + j _reset_itvector +_reset_proc3: + li $13, 0b010010001100 # offset for MSK_HWI_ENABLE & proc[3] + addu $13, $20, $13 + li $27, 0x088 # TTY[3] DMA[3] + sw $27, 0($13) # MASK[3] + j _reset_itvector + nop + +_reset_switch: + .word _reset_proc0 + .word _reset_proc1 + .word _reset_proc2 + .word _reset_proc3 + +# only processor 0 in cluster 0 initializes interrupt vector + +_reset_itvector: + bne $10, $0, _reset_end + nop + la $26, _interrupt_vector # interrupt vector address + la $27, _isr_dma + sw $27, 0($26) # interrupt_vector[0] <= _isr_dma_get + sw $27, 4($26) # interrupt_vector[1] <= _isr_dma_get + sw $27, 8($26) # interrupt_vector[2] <= _isr_dma_get + sw $27, 12($26) # interrupt_vector[3] <= _isr_dma_get + la $27, _isr_tty_get + sw $27, 16($26) # interrupt_vector[4] <= _isr_tty + sw $27, 20($26) # interrupt_vector[5] <= _isr_tty + sw $27, 24($26) # interrupt_vector[6] <= _isr_tty + sw $27, 28($26) # interrupt_vector[7] <= _isr_tty + la $27, _isr_ioc + sw $27, 32($26) # interrupt_vector[8] <= _isr_ioc + +_reset_end: + +# initializes SR register + li $26, 0x0000FF01 + mtc0 $26, $12 # SR <= kernel mode / IRQ enable + +# jumps to main in kernel mode + la $26, main + jr $26 + nop + + .end reset + + .set reorder Index: trunk/softs/giet_tsar/stdio.c =================================================================== --- trunk/softs/giet_tsar/stdio.c (revision 620) +++ trunk/softs/giet_tsar/stdio.c (revision 620) @@ -0,0 +1,833 @@ +/********************************************************************* + fichier stdio.c + Written Alain greiner & Nicolas Pouillon + Date : 19/10/2009 + + These function implement the drivers for the SoCLib peripherals. + *********************************************************************/ + +#include + +#include "stdio.h" + +#include "timer.h" +#include "tty.h" +#include "gcd.h" +#include "icu.h" +#include "dma.h" +#include "block_device.h" + +/********************************************************************* + We define a generic C function to implement all system calls. + *********************************************************************/ +inline int sys_call( int call_no, + int arg_0, + int arg_1, + int arg_2, + int arg_3 ) +{ + register int reg_no_and_output asm("v0") = call_no; + register int reg_a0 asm("a0") = arg_0; + register int reg_a1 asm("a1") = arg_1; + register int reg_a2 asm("a2") = arg_2; + register int reg_a3 asm("a3") = arg_3; + + asm volatile( + "syscall" + : "=r" (reg_no_and_output) // arguments de sortie + : "r" (reg_a0), // arguments d'entrée + "r" (reg_a1), + "r" (reg_a2), + "r" (reg_a3), + "r" (reg_no_and_output) + : "memory", // ressources modifiees: + "at", + "v1", + "ra", // Ces registres persistants seront sauvegardes + "t0", // sur la pile par le compilateur + "t1", // seulement s'ils contiennent des donnees + "t2", // calculees par la fonction effectuant le syscall, + "t3", // et que ces valeurs sont reutilisees par cette + "t4", // fonction au retour du syscall. + "t5", + "t6", + "t7", + "t8", + "t9" + ); + return reg_no_and_output; +} + +/******************************************************************** + procid() + Returns the processor ident. + ********************************************************************/ +int procid() +{ + return sys_call(SYSCALL_PROCID, 0, 0, 0, 0); +} +/******************************************************************** + proctime() + Returns the local processor time. + ********************************************************************/ +int proctime() +{ + return sys_call(SYSCALL_PROCTIME, 0, 0, 0, 0); +} +/******************************************************************** + procnumber() + Returns the number of processors controled by the system. + ********************************************************************/ +int procnumber() +{ + return sys_call(SYSCALL_PROCNUMBER, 0, 0, 0, 0); +} +/******************************************************************** + exit() + Exit the program with a TTY message, and enter an infinite loop... + ********************************************************************/ +int exit() +{ + int proc_index = procid(); + return sys_call(SYSCALL_EXIT, proc_index, 0, 0, 0); +} +/******************************************************************** + rand() + Returns a pseudo-random value derived from the processor cycle count. + This value is comprised between 0 & 65535. + ********************************************************************/ +int rand() +{ + int x = sys_call(SYSCALL_PROCTIME, 0, 0, 0, 0); + if((x & 0xF) > 7) + return (x*x & 0xFFFF); + else + return (x*x*x & 0xFFFF); +} + +/************************************************************************* + MULTI-TTY + ************************************************************************** + tty_putc() + Display a single ascii character on a terminal. + The terminal index is implicitely defined by the processor ID. + (and by the task ID in case of multi-tasking) + It doesn't use the TTY_PUT_IRQ interrupt, and the associated kernel buffer. + This function returns 0 in case of success. + ******************************i*******************************************/ +int tty_putc(char byte) +{ + return sys_call(SYSCALL_TTY_WRITE, + (int)(&byte), + 1, + 0,0); +} +/************************************************************************* + tty_puts() + Display a string on a terminal. + The terminal index is implicitely defined by the processor ID. + (and by the task ID in case of multi-tasking) + The string must be terminated by a NUL character. + It doesn't use the TTY_PUT_IRQinterrupt, and the associated kernel buffer. + This function returns 0 in case of success. + **************************************************************************/ +int tty_puts(char* string) +{ + int length = 0; + while (string[length] != 0) { + length++; + } + return sys_call(SYSCALL_TTY_WRITE, + (int)string, + length, + 0,0); +} +/************************************************************************* + tty_putw() + Display the value of a 32 bits word (decimal characters). + The terminal index is implicitely defined by the processor ID. + (and by pthe task ID in case of multi-tasking) + It doesn't use the TTY_PUT_IRQ interrupt, and the associated kernel buffer. + This function returns 0 in case of success. + **************************************************************************/ +int tty_putw(int val) +{ + char buf[10]; + int i; + for( i=0 ; i<10 ; i++ ) { + buf[9-i] = (val % 10) + 0x30; + val = val / 10; + } + return sys_call(SYSCALL_TTY_WRITE, + (int)buf, + 10, + 0,0); +} +/******************************************************************** + tty_getc() + Fetch a single ascii character from a terminal. + The terminal index is implicitely defined by the processor ID. + (and by the task ID in case of multi-tasking) + It doesn't use the IRQ_GET interrupt, and the associated kernel buffer. + It is a blocking function that returns 0 if a valid char is stored + in the buffer, and returns -1 in case of error. + ********************************************************************/ +int tty_getc(char* buf) +{ + int ret = 0; + while( ret == 0 ) + { + ret = sys_call(SYSCALL_TTY_READ, + (int)buf, + 1, + 0,0); + if ((ret < 0) || (ret > 1)) return -1; // return error + } + return 0; // return ok +} +/******************************************************************** + tty_getc_irq() + Fetch a single ascii character from a terminal. + The terminal index is implicitely defined by the processor ID. + (and by the task ID in case of multi-tasking) + It uses the IRQ_GET interrupt, and the associated kernel buffer. + It is a blocking function that returns 0 if a valid char is stored + in the buffer, and returns -1 in case of error. + ********************************************************************/ +int tty_getc_irq(char* buf) +{ + int ret = 0; + while( ret == 0 ) + { + ret = sys_call(SYSCALL_TTY_READ_IRQ, + (int)buf, + 1, + 0,0); + if ((ret < 0) || (ret > 1)) return -1; // return error + } + return 0; // return ok +} +/******************************************************************** + tty_gets_irq() + Fetch a string from a terminal to a bounded length buffer. + The terminal index is implicitely defined by the processor ID. + (and by the task ID in case of multi-tasking) + It uses the TTY_GET_IRQ interrupt, anf the associated kernel buffer. + It is a blocking function that returns 0 if a valid string is stored + in the buffer, and returns -1 in case of error. + Up to (bufsize - 1) characters (including the non printable + characters) will be copied into buffer, and the string is + always completed by a NUL character. + The character is interpreted, as the function close + the string with a NUL character if is read. + The character is interpreted, and the corresponding + character(s) are removed from the target buffer. + ********************************************************************/ +int tty_gets_irq(char* buf, int bufsize) +{ + int ret; + unsigned char byte; + unsigned int index = 0; + + while( index < (bufsize-1) ) + { + ret = sys_call(SYSCALL_TTY_READ_IRQ, + (int)(&byte), + 1, + 0,0); + + if ((ret < 0) || (ret > 1)) return -1; // return error + + else if ( ret == 1 ) // valid character + { + if ( byte == 0x0A ) break; // LF + else if ((byte == 0x7F) && (index>0)) index--; // DEL + else + { + buf[index] = byte; + index++; + } + } + } // end while + buf[index] = 0; + return 0; // return ok +} +/******************************************************************** + tty_getw_irq() + Fetch a string of decimal characters (most significant digit first) + to build a 32 bits unsigned int. + The terminal index is implicitely defined by the processor ID. + (and by the task ID in case of multi-tasking) + This is a blocking function that returns 0 if a valid unsigned int + is stored in the buffer, and returns -1 in case of error. + It uses the TTY_GET_IRQ interrupt, anf the associated kernel buffer. + The non-blocking system function _tty_read_irq is called several times, + and the decimal characters are written in a 32 characters buffer + until a character is read. + The character is interpreted, and previous characters can be + cancelled. All others characters are ignored. + When the character is received, the string is converted to + an unsigned int value. If the number of decimal digit is too large + for the 32 bits range, the zero value is returned. + ********************************************************************/ +int tty_getw_irq(int* word_buffer) +{ + unsigned char buf[32]; + unsigned char byte; + unsigned int save = 0; + unsigned int val = 0; + unsigned int done = 0; + unsigned int overflow = 0; + unsigned int max = 0; + unsigned int i; + int ret; + + while(done == 0) + { + ret = sys_call(SYSCALL_TTY_READ_IRQ, + (int)(&byte), + 1, + 0,0); + if ((ret < 0) || (ret > 1)) return -1; // return error + + if ( ret == 1 ) // get one character + { + if (( byte > 0x2F) && (byte < 0x3A)) // decimal character + { + buf[max] = byte; + max++; + tty_putc(byte); + } + else if ( (byte == 0x0A) || (byte == 0x0D) ) // LF or CR character + { + done = 1; + } + else if ( byte == 0x7F ) // DEL character + { + if (max > 0) + { + max--; // cancel the character + tty_putc(0x08); + tty_putc(0x20); + tty_putc(0x08); + } + } + if ( max == 32 ) // decimal string overflow + { + for( i=0 ; i $@.txt + +reset.o: $(GIET)/reset.s + $(AS) -g -mips32 -o $@ $< + $(DU) -D $@ > $@.txt + +giet.o: $(GIET)/giet.s + $(AS) -g -mips32 -o $@ $< + $(DU) -D $@ > $@.txt + +isr.o: $(GIET)/isr.c + $(CC) $(CFLAGS) -c -o $@ $< + $(DU) -D $@ > $@.txt + +stdio.o: $(GIET)/stdio.c + $(CC) $(CFLAGS) -c -o $@ $< + $(DU) -D $@ > $@.txt + +drivers.o: $(GIET)/drivers.c + $(CC) $(CFLAGS) -c -o $@ $< + $(DU) -D $@ > $@.txt + +main.o: main.c + $(CC) $(CFLAGS) -I$(GIET) -c -o $@ $< + $(DU) -D $@ > $@.txt + +clean: + rm -f *.o bin.soft *.txt core *~ proc* term* temp Index: trunk/softs/soft_filter_giet/ldscript =================================================================== --- trunk/softs/soft_filter_giet/ldscript (revision 620) +++ trunk/softs/soft_filter_giet/ldscript (revision 620) @@ -0,0 +1,90 @@ +/********************************************************** + File : ldscript + Author : Alain Greiner + Date : March 2011 +**********************************************************/ + +/* definition of various hardware parameters. +These variables are referenced in the drivers.c file, +and must be defined, even if the corresponding +peripherals are not present in the architecture */ + +NB_CLUSTERS = 4; /* number of clusters */ +NB_PROCS = 4; /* number of processors per cluster */ +NB_TASKS = 1; /* number of tasks per processor */ +NB_TIMERS = 1; /* max number of timers per processor */ +NB_LOCKS = 8; /* number of spin_locks */ + +/* definition of the base address for all segments +The peripherals base addresses are referenced by the +software drivers and must be defined, even if the +peripherals are not present in the architecture */ + +seg_code_base = 0x00000000; /* le code utilisateur */ +seg_data_base = 0x00100000; /* les données utilisateur */ + +seg_heap_base = 0x00300000; /* le tas utilisateur */ +seg_stack_base = 0x00800000; /* la pile utilisateur */ + +seg_kcode_base = 0x80000000; /* le code du système */ +seg_kdata_base = 0x80100000; /* les donnees du système */ +seg_kunc_base = 0x80200000; /* les données non cachées du système */ + +seg_icu_base = 0x00F00000; /* controleur ICU */ +seg_tty_base = 0xBFF20000; /* controleur TTY */ +seg_dma_base = 0x00F30000; /* controleur DMA */ + +seg_reset_base = 0xBFC00000; /* le code de boot */ +seg_fb_base = 0xBFD00000; /* controleur FRAME BUFFER */ +seg_ioc_base = 0xBFF10000; /* controleur I/O */ + +seg_timer_base = 0x00F0000; /* controleur TIMER */ +seg_gcd_base = 0xBFF50000; /* controleur GCD */ + +/* Grouping sections into segments */ + +SECTIONS +{ + . = seg_kcode_base; + seg_kcode : { + *(.giet) + *(.switch) + *(.drivers) + *(.isr) + } + . = seg_kdata_base; + seg_kdata : { + *(.kdata) + } + . = seg_kunc_base; + seg_kunc : { + *(.unckdata) + } + . = seg_kdata_base; + seg_kdata : { + *(.ksave) + } + . = seg_code_base; + seg_code : { + *(.text) + } + . = seg_reset_base; + seg_reset : { + *(.reset) + } + . = seg_data_base; + seg_data : { + *(.rodata) + . = ALIGN(4); + *(.rodata.*) + . = ALIGN(4); + *(.data) + . = ALIGN(4); + *(.sdata) + . = ALIGN(4); + *(.bss) + *(COMMON) + *(.sbss) + } +} + Index: trunk/softs/soft_filter_giet/main.c =================================================================== --- trunk/softs/soft_filter_giet/main.c (revision 620) +++ trunk/softs/soft_filter_giet/main.c (revision 620) @@ -0,0 +1,631 @@ + +#include "limits.h" +#include "stdio.h" + +#include "../giet_tsar/block_device.h" + +//////////////////////////////////// +// Image parameters + +#define NB_CLUSTER_MAX 256 +#define PIXEL_SIZE 2 +#define NL 1024 +#define NP 1024 + +#define NB_PIXELS ((NP) * (NL)) +#define FRAME_SIZE ((NB_PIXELS) * (PIXEL_SIZE)) + +#define PRINTF(...) ({ if (proc_id == 0) { tty_printf(__VA_ARGS__); } }) + +#define TA(c,l,p) (A[c][((NP) * (l)) + (p)]) +#define TB(c,p,l) (B[c][((NL) * (p)) + (l)]) +#define TC(c,l,p) (C[c][((NP) * (l)) + (p)]) +#define TD(c,l,p) (D[c][((NP) * (l)) + (p)]) +#define TZ(c,l,p) (Z[c][((NP) * (l)) + (p)]) + +#define max(x,y) ((x) > (y) ? (x) : (y)) +#define min(x,y) ((x) < (y) ? (x) : (y)) + +/////////////////////////////////////////// +// tricks to read parameters from ldscript +/////////////////////////////////////////// + +struct plaf; + +extern struct plouf seg_ioc_base; +extern struct plaf seg_heap_base; +extern struct plaf NB_PROCS; +extern struct plaf NB_CLUSTERS; + + +// Required when initializing an array all at once +static void *memcpy(void *_dst, const void *_src, unsigned int size){ + unsigned int *dst = _dst; + const unsigned int *src = _src; + if (! ((unsigned int)dst & 3) && ! ((unsigned int)src & 3)){ + while (size > 3){ + *dst++ = *src++; + size -= 4; + } + } + + unsigned char *cdst = (unsigned char*)dst; + unsigned char *csrc = (unsigned char*)src; + + while (size--){ + *cdst++ = *csrc++; + } + return _dst; +} + + + + + + + + +void main(){ + + ////////////////////////////////// + // convolution kernel parameters + // The content of this section is + // Philips proprietary information. + /////////////////////////////////// + + int vnorm = 115; + int vf[35] = { 1, 1, 2, 2, 2, + 2, 3, 3, 3, 4, + 4, 4, 4, 5, 5, + 5, 5, 5, 5, 5, + 5, 5, 4, 4, 4, + 4, 3, 3, 3, 2, + 2, 2, 2, 1, 1 }; + + int hrange = 100; + int hnorm = 201; + + unsigned int date = 0; + + int c; // cluster index for loops + int l; // line index for loops + int p; // pixel index for loops + int x; // filter index for loops + + const unsigned int proc_id = procid(); // processor id + const unsigned int nlocal_procs = (int) &NB_PROCS; // number of processors per cluster + const unsigned int nclusters = (int) &NB_CLUSTERS; // number of clusters + const unsigned int local_id = proc_id % nlocal_procs; // local task id + const unsigned int cluster_id = proc_id / nlocal_procs; // cluster task id + const unsigned int base = (unsigned int) &seg_heap_base; // base address for shared buffers + const unsigned int increment = 0x80000000 / nclusters * 2; // cluster increment + const unsigned int nglobal_procs = nclusters * nlocal_procs; // number of tasks + const unsigned int npixels = NB_PIXELS; // Number of pixel per frame + const unsigned int frame_size = FRAME_SIZE; // Size of 1 frame (in bytes) + const unsigned int * ioc_address = (unsigned int *) &seg_ioc_base; + const unsigned int block_size = ioc_address[BLOCK_DEVICE_BLOCK_SIZE]; + const unsigned int nblocks = frame_size / block_size; // number of blocks per frame + + const unsigned int lines_per_task = NL / nglobal_procs; // number of lines per task + const unsigned int lines_per_cluster = NL / nclusters; // number of lines per cluster + const unsigned int pixels_per_task = NP / nglobal_procs; // number of columns per task + const unsigned int pixels_per_cluster = NP / nclusters; // number of columns per cluster + + int first, last; + + PRINTF("\n*** Processor %d entering main at cycle %d ***\n\n", proc_id, proctime()); + + + ///////////////////////// + // parameters checking // + ///////////////////////// + + + if ((nlocal_procs != 1) && (nlocal_procs != 2) && (nlocal_procs != 4)){ + PRINTF("NB_PROCS must be 1, 2 or 4\n"); + exit(); + } + + //////////////////////////////////////////////////////////////////////// + // Warning: NB_CLUSTERS must be at least 4 because of the heap size; // + // if there are less clusters, the heap mixes with the stack // + // (the total heap size must be at least 0x01000000) // + //////////////////////////////////////////////////////////////////////// + if ((nclusters != 4) && (nclusters != 8) && (nclusters != 16) && + (nclusters != 32) && (nclusters != 64) && (nclusters !=128) && (nclusters != 256)){ + PRINTF("NB_CLUSTERS must be a power of 2 between 4 and 256\n"); + exit(); + } + + if (proc_id >= nglobal_procs){ + PRINTF("processor id %d larger than NB_CLUSTERS*NB_PROCS\n", proc_id); + exit(); + } + + if (NL % nclusters != 0){ + PRINTF("NB_CLUSTERS must be a divider of NL"); + exit(); + } + + if (NP % nclusters != 0){ + PRINTF("NB_CLUSTERS must be a divider of NP"); + exit(); + } + + + // Arrays of pointers on the shared, distributed buffers + // containing the images (sized for the worst case : 256 clusters) + unsigned short * A[NB_CLUSTER_MAX]; + int * B[NB_CLUSTER_MAX]; + int * C[NB_CLUSTER_MAX]; + int * D[NB_CLUSTER_MAX]; + unsigned char * Z[NB_CLUSTER_MAX]; + + // Arrays of pointers on the instrumentation arrays + // These arrays are indexed by the cluster index (sized for the worst case : 256 clusters) + // each pointer points on the base adress of an array of 4 (NPROCS max) unsigned int + unsigned int * LOAD_START[NB_CLUSTER_MAX]; + unsigned int * LOAD_END[NB_CLUSTER_MAX]; + unsigned int * VERT_START[NB_CLUSTER_MAX]; + unsigned int * VERT_END[NB_CLUSTER_MAX]; + unsigned int * HORI_START[NB_CLUSTER_MAX]; + unsigned int * HORI_END[NB_CLUSTER_MAX]; + unsigned int * DISP_START[NB_CLUSTER_MAX]; + unsigned int * DISP_END[NB_CLUSTER_MAX]; + + // The shared, distributed buffers addresses are computed + // from the seg_heap_base value defined in the ldscript file + // and from the cluster increment = 4Gbytes/nclusters. + // These arrays of pointers are identical and + // replicated in the stack of each task + for (c = 0; c < nclusters; c++){ + unsigned int offset = base + increment * c; + A[c] = (unsigned short *) (offset); + B[c] = (int *) (offset + frame_size * 1 / nclusters); // We increment by 2 * frame_size + C[c] = (int *) (offset + frame_size * 3 / nclusters); // because sizeof(int) = 2*sizeof(short) + D[c] = (int *) (offset + frame_size * 5 / nclusters); // so an array of frame_size elements of type + Z[c] = (unsigned char *) (offset + frame_size * 7 / nclusters); // int can contain the equivalent of 2 frames + + offset = base + increment * c + frame_size * 8 / nclusters; + LOAD_START[c] = (unsigned int *) (offset + nlocal_procs * sizeof(unsigned int) * 0); + LOAD_END[c] = (unsigned int *) (offset + nlocal_procs * sizeof(unsigned int) * 1); + VERT_START[c] = (unsigned int *) (offset + nlocal_procs * sizeof(unsigned int) * 2); + VERT_END[c] = (unsigned int *) (offset + nlocal_procs * sizeof(unsigned int) * 3); + HORI_START[c] = (unsigned int *) (offset + nlocal_procs * sizeof(unsigned int) * 4); + HORI_END[c] = (unsigned int *) (offset + nlocal_procs * sizeof(unsigned int) * 5); + DISP_START[c] = (unsigned int *) (offset + nlocal_procs * sizeof(unsigned int) * 6); + DISP_END[c] = (unsigned int *) (offset + nlocal_procs * sizeof(unsigned int) * 7); + } + + PRINTF("NB_CLUSTERS = %d\n", nclusters); + PRINTF("NB_LOCAL_PROCS = %d\n", nlocal_procs); + PRINTF("NB_GLOBAL_PROCS = %d\n", nglobal_procs); + PRINTF("NB_PIXELS = %d\n", npixels); + PRINTF("PIXEL_SIZE = %d\n", PIXEL_SIZE); + PRINTF("FRAME_SIZE = %d\n", frame_size); + PRINTF("BLOCK_SIZE = %d\n", block_size); + PRINTF("NB_BLOCKS = %d\n\n", nblocks); + + + PRINTF("*** Starting barrier init at cycle %d ***\n", proctime()); + + // barriers initialization + barrier_init(0, nglobal_procs); + barrier_init(1, nglobal_procs); + barrier_init(2, nglobal_procs); + barrier_init(3, nglobal_procs); + + PRINTF("*** Completing barrier init at cycle %d ***\n", proctime()); + + + //////////////////////////////////////////////////////// + // pseudo parallel load from disk to A[c] buffers + // only task running on processor with (local_id==0) does it + // nblocks/nclusters are loaded in each cluster + //////////////////////////////////////////////////////// + + if (local_id == 0){ + int p; + date = proctime(); + PRINTF("\n*** Starting load at cycle %d\n", date); + for (p = 0; p < nlocal_procs; p++){ + LOAD_START[cluster_id][p] = date; + } + + if (ioc_read(nblocks*cluster_id/nclusters, A[cluster_id], nblocks/nclusters)){ + PRINTF("echec ioc_read\n"); + exit(1); + } + if (ioc_completed()){ + PRINTF("echec ioc_completed\n"); + exit(1); + } + + date = proctime(); + PRINTF("*** Completing load at cycle %d\n", date); + for (p = 0; p < nlocal_procs; p++){ + LOAD_END[cluster_id][p] = date; + } + } + + barrier_wait(0); + + + //////////////////////////////////////////////////////// + // parallel horizontal filter : + // B <= transpose(FH(A)) + // D <= A - FH(A) + // Each task computes (NL/nglobal_procs) lines + // The image must be extended : + // if (z<0) TA(cluster_id,l,z) == TA(cluster_id,l,0) + // if (z>NP-1) TA(cluster_id,l,z) == TA(cluster_id,l,NP-1) + //////////////////////////////////////////////////////// + + date = proctime(); + PRINTF("\n*** Starting horizontal filter at cycle %d\n", date); + HORI_START[cluster_id][local_id] = date; + + // l = absolute line index / p = absolute pixel index + // first & last define which lines are handled by a given task(cluster_id,local_id) + + first = (cluster_id * nlocal_procs + local_id) * lines_per_task; + last = first + lines_per_task; + + for (l = first; l < last; l++){ + // src_c and src_l are the cluster index and the line index for A & D + int src_c = l / lines_per_cluster; + int src_l = l % lines_per_cluster; + + // We use the specific values of the horizontal ep-filter for optimisation: + // sum(p) = sum(p-1) + TA[p+hrange] - TA[p-hrange-1] + // To minimize the number of tests, the loop on pixels is split in three domains + + int sum_p = (hrange + 2) * TA(src_c, src_l, 0); + for (x = 1; x < hrange; x++){ + sum_p = sum_p + TA(src_c, src_l, x); + } + + // first domain : from 0 to hrange + for (p = 0; p < hrange + 1; p++){ + // dst_c and dst_p are the cluster index and the pixel index for B + int dst_c = p / pixels_per_cluster; + int dst_p = p % pixels_per_cluster; + sum_p = sum_p + (int) TA(src_c, src_l, p + hrange) - (int) TA(src_c, src_l, 0); + TB(dst_c, dst_p, l) = sum_p / hnorm; + TD(src_c, src_l, p) = (int) TA(src_c, src_l, p) - sum_p / hnorm; + } + // second domain : from (hrange+1) to (NP-hrange-1) + for (p = hrange + 1; p < NP - hrange; p++){ + // dst_c and dst_p are the cluster index and the pixel index for B + int dst_c = p / pixels_per_cluster; + int dst_p = p % pixels_per_cluster; + sum_p = sum_p + (int) TA(src_c, src_l, p + hrange) - (int) TA(src_c, src_l, p - hrange - 1); + TB(dst_c, dst_p, l) = sum_p / hnorm; + TD(src_c, src_l, p) = (int) TA(src_c, src_l, p) - sum_p / hnorm; + } + // third domain : from (NP-hrange) to (NP-1) + for (p = NP - hrange; p < NP; p++){ + // dst_c and dst_p are the cluster index and the pixel index for B + int dst_c = p / pixels_per_cluster; + int dst_p = p % pixels_per_cluster; + sum_p = sum_p + (int) TA(src_c, src_l, NP - 1) - (int) TA(src_c, src_l, p - hrange - 1); + TB(dst_c, dst_p, l) = sum_p / hnorm; + TD(src_c, src_l, p) = (int) TA(src_c, src_l, p) - sum_p / hnorm; + } + + PRINTF(" - line %d computed at cycle %d\n", l, proctime()); + } + + date = proctime(); + PRINTF("*** Completing horizontal filter at cycle %d\n", date); + HORI_END[cluster_id][local_id] = date; + + barrier_wait(1); + + + ////////////////////////////////////////////////////////// + // parallel vertical filter : + // C <= transpose(FV(B)) + // Each task computes (NP/nglobal_procs) columns + // The image must be extended : + // if (l<0) TB(cluster_id,p,x) == TB(cluster_id,p,0) + // if (l>NL-1) TB(cluster_id,p,x) == TB(cluster_id,p,NL-1) + ////////////////////////////////////////////////////////// + + date = proctime(); + PRINTF("\n*** starting vertical filter at cycle %d\n", date); + VERT_START[cluster_id][local_id] = date; + + // l = absolute line index / p = absolute pixel index + // first & last define which pixels are handled by a given task(cluster_id,local_id) + + first = (cluster_id * nlocal_procs + local_id) * pixels_per_task; + last = first + pixels_per_task; + + for (p = first; p < last; p++){ + // src_c and src_p are the cluster index and the pixel index for B + int src_c = p / pixels_per_cluster; + int src_p = p % pixels_per_cluster; + + int sum_l; + + // We use the specific values of the vertical ep-filter + // To minimize the number of tests, the NL lines are split in three domains + + // first domain : explicit computation for the first 18 values + for (l = 0; l < 18; l++){ + // dst_c and dst_l are the cluster index and the line index for C + int dst_c = l / lines_per_cluster; + int dst_l = l % lines_per_cluster; + + for (x = 0, sum_l = 0; x < 35; x++){ + sum_l = sum_l + vf[x] * TB(src_c, src_p, max(l - 17 + x,0) ); + } + TC(dst_c, dst_l, p) = sum_l / vnorm; + } + // second domain + for (l = 18; l < NL - 17; l++){ + // dst_c and dst_l are the cluster index and the line index for C + int dst_c = l / lines_per_cluster; + int dst_l = l % lines_per_cluster; + + sum_l = sum_l + TB(src_c, src_p, l + 4) + + TB(src_c, src_p, l + 8) + + TB(src_c, src_p, l + 11) + + TB(src_c, src_p, l + 15) + + TB(src_c, src_p, l + 17) + - TB(src_c, src_p, l - 5) + - TB(src_c, src_p, l - 9) + - TB(src_c, src_p, l - 12) + - TB(src_c, src_p, l - 16) + - TB(src_c, src_p, l - 18); + TC(dst_c, dst_l, p) = sum_l / vnorm; + } + // third domain + for (l = NL - 17; l < NL; l++){ + // dst_c and dst_l are the cluster index and the line index for C + int dst_c = l / lines_per_cluster; + int dst_l = l % lines_per_cluster; + + sum_l = sum_l + TB(src_c, src_p, min(l + 4, NL - 1)) + + TB(src_c, src_p, min(l + 8, NL - 1)) + + TB(src_c, src_p, min(l + 11, NL - 1)) + + TB(src_c, src_p, min(l + 15, NL - 1)) + + TB(src_c, src_p, min(l + 17, NL - 1)) + - TB(src_c, src_p, l - 5) + - TB(src_c, src_p, l - 9) + - TB(src_c, src_p, l - 12) + - TB(src_c, src_p, l - 16) + - TB(src_c, src_p, l - 18); + TC(dst_c, dst_l, p) = sum_l / vnorm; + } + PRINTF(" - column %d computed at cycle %d\n", p, proctime()); + } + + date = proctime(); + PRINTF("*** Completing vertical filter at cycle %d\n", date); + VERT_END[cluster_id][local_id] = date; + + barrier_wait(2); + + + //////////////////////////////////////////////////////////////// + // final computation and parallel display + // Z <= D + C + // Each processor use its private DMA channel to display + // the resulting image, line per line (one byte per pixel). + // Eah processor computes & displays (NL/nglobal_procs) lines. + //////////////////////////////////////////////////////////////// + + date = proctime(); + PRINTF("\n*** Starting display at cycle %d\n", date); + DISP_START[cluster_id][local_id] = date; + + first = local_id * lines_per_task; + last = first + lines_per_task; + + for (l = first; l < last; l++){ + for (p = 0; p < NP; p++){ + TZ(cluster_id,l,p) = (unsigned char) (((TD(cluster_id,l,p) + TC(cluster_id,l,p)) >> 8) & 0xFF); + } + fb_write(NP * (cluster_id * lines_per_cluster + l), &TZ(cluster_id,l,0), NP); + } + + date = proctime(); + PRINTF("*** Completing display at cycle %d\n", date); + DISP_END[cluster_id][local_id] = date; + + barrier_wait(3); + + + ///////////////////////////////////////////////////////// + // Instrumentation (done by processor 0 in cluster 0) + ///////////////////////////////////////////////////////// + + if (proc_id == 0){ + date = proctime(); + PRINTF("\n*** Starting Instrumentation at cycle %d\n\n", date); + + int cc, pp; + unsigned int min_load_start = INT_MAX; + unsigned int max_load_start = 0; + unsigned int min_load_ended = INT_MAX; + unsigned int max_load_ended = 0; + + unsigned int min_hori_start = INT_MAX; + unsigned int max_hori_start = 0; + unsigned int min_hori_ended = INT_MAX; + unsigned int max_hori_ended = 0; + + unsigned int min_vert_start = INT_MAX; + unsigned int max_vert_start = 0; + unsigned int min_vert_ended = INT_MAX; + unsigned int max_vert_ended = 0; + + unsigned int min_disp_start = INT_MAX; + unsigned int max_disp_start = 0; + unsigned int min_disp_ended = INT_MAX; + unsigned int max_disp_ended = 0; + + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++ ){ + if (LOAD_START[cc][pp] < min_load_start){ + min_load_start = LOAD_START[cc][pp]; + } + if (LOAD_START[cc][pp] > max_load_start){ + max_load_start = LOAD_START[cc][pp]; + } + if (LOAD_END[cc][pp] < min_load_ended){ + min_load_ended = LOAD_END[cc][pp]; + } + if (LOAD_END[cc][pp] > max_load_ended){ + max_load_ended = LOAD_END[cc][pp]; + } + + if (HORI_START[cc][pp] < min_hori_start){ + min_hori_start = HORI_START[cc][pp]; + } + if (HORI_START[cc][pp] > max_hori_start){ + max_hori_start = HORI_START[cc][pp]; + } + if (HORI_END[cc][pp] < min_hori_ended){ + min_hori_ended = HORI_END[cc][pp]; + } + if (HORI_END[cc][pp] > max_hori_ended){ + max_hori_ended = HORI_END[cc][pp]; + } + + if (VERT_START[cc][pp] < min_vert_start){ + min_vert_start = VERT_START[cc][pp]; + } + if (VERT_START[cc][pp] > max_vert_start){ + max_vert_start = VERT_START[cc][pp]; + } + if (VERT_END[cc][pp] < min_vert_ended){ + min_vert_ended = VERT_END[cc][pp]; + } + if (VERT_END[cc][pp] > max_vert_ended){ + max_vert_ended = VERT_END[cc][pp]; + } + + if (DISP_START[cc][pp] < min_disp_start){ + min_disp_start = DISP_START[cc][pp]; + } + if (DISP_START[cc][pp] > max_disp_start){ + max_disp_start = DISP_START[cc][pp]; + } + if (DISP_END[cc][pp] < min_disp_ended){ + min_disp_ended = DISP_END[cc][pp]; + } + if (DISP_END[cc][pp] > max_disp_ended){ + max_disp_ended = DISP_END[cc][pp]; + } + } + } + PRINTF(" - LOAD_START : min = %d / max = %d / med = %d / delta = %d\n", + min_load_start, max_load_start, (min_load_start+max_load_start) / 2, max_load_start-min_load_start); + PRINTF(" - LOAD_END : min = %d / max = %d / med = %d / delta = %d\n", + min_load_ended, max_load_ended, (min_load_ended+max_load_ended) / 2, max_load_ended-min_load_ended); + + PRINTF(" - HORI_START : min = %d / max = %d / med = %d / delta = %d\n", + min_hori_start, max_hori_start, (min_hori_start+max_hori_start) / 2, max_hori_start-min_hori_start); + PRINTF(" - HORI_END : min = %d / max = %d / med = %d / delta = %d\n", + min_hori_ended, max_hori_ended, (min_hori_ended+max_hori_ended) / 2, max_hori_ended-min_hori_ended); + + PRINTF(" - VERT_START : min = %d / max = %d / med = %d / delta = %d\n", + min_vert_start, max_vert_start, (min_vert_start+max_vert_start) / 2, max_vert_start-min_vert_start); + PRINTF(" - VERT_END : min = %d / max = %d / med = %d / delta = %d\n", + min_vert_ended, max_vert_ended, (min_vert_ended+max_vert_ended) / 2, max_vert_ended-min_vert_ended); + + PRINTF(" - DISP_START : min = %d / max = %d / med = %d / delta = %d\n", + min_disp_start, max_disp_start, (min_disp_start+max_disp_start) / 2, max_disp_start-min_disp_start); + PRINTF(" - DISP_END : min = %d / max = %d / med = %d / delta = %d\n", + min_disp_ended, max_disp_ended, (min_disp_ended+max_disp_ended) / 2, max_disp_ended-min_disp_ended); + + PRINTF(" - BARRIER LOAD/HORI = %d\n", min_hori_start - max_load_ended); + PRINTF(" - BARRIER HORI/VERT = %d\n", min_vert_start - max_hori_ended); + PRINTF(" - BARRIER VERT/DISP = %d\n", min_disp_start - max_vert_ended); + + PRINTF(" - LOAD = %d\n", max_load_ended); + PRINTF(" - FILTER = %d\n", max_vert_ended - max_load_ended); + PRINTF(" - DISPLAY = %d\n", max_disp_ended - max_vert_ended); + + PRINTF("\nBEGIN LOAD_START\n"); + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++){ + PRINTF("cluster= %d proc= %d date= %d\n", cc, pp, LOAD_START[cc][pp]); + } + } + PRINTF("END\n"); + + PRINTF("\nBEGIN LOAD_END\n"); + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++){ + PRINTF("cluster= %d proc= %d date= %d\n", cc, pp, LOAD_END[cc][pp]); + } + } + PRINTF("END\n"); + + PRINTF("\nBEGIN HORI_START\n"); + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++){ + PRINTF("cluster= %d proc= %d date= %d\n", cc, pp, HORI_START[cc][pp]); + } + } + PRINTF("END\n"); + + PRINTF("\nBEGIN HORI_END\n"); + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++){ + PRINTF("cluster= %d proc= %d date= %d\n", cc, pp, HORI_END[cc][pp]); + } + } + PRINTF("END\n"); + + PRINTF("\nBEGIN VERT_START\n"); + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++){ + PRINTF("cluster= %d proc= %d date= %d\n", cc, pp, VERT_START[cc][pp]); + } + } + PRINTF("END\n"); + + PRINTF("\nBEGIN VERT_END\n"); + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++ ){ + PRINTF("cluster= %d proc= %d date= %d\n", cc, pp, VERT_END[cc][pp]); + } + } + PRINTF("END\n"); + + PRINTF("\nBEGIN DISP_START\n"); + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++){ + PRINTF("cluster= %d proc= %d date= %d\n", cc, pp, DISP_START[cc][pp]); + } + } + PRINTF("END\n"); + + PRINTF("\nBEGIN DISP_END\n"); + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++){ + PRINTF("cluster= %d proc= %d date= %d\n", cc, pp, DISP_END[cc][pp]); + } + } + PRINTF("END\n"); + } + + while(1); + +} // end main() + +// Local Variables: +// tab-width: 3 +// c-basic-offset: 3 +// c-file-offsets:((innamespace . 0)(inline-open . 0)) +// indent-tabs-mode: nil +// End: + +// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3 + + Index: trunk/softs/soft_transpose_giet/Makefile =================================================================== --- trunk/softs/soft_transpose_giet/Makefile (revision 620) +++ trunk/softs/soft_transpose_giet/Makefile (revision 620) @@ -0,0 +1,46 @@ +LD = mipsel-unknown-elf-ld +CC = mipsel-unknown-elf-gcc +AS = mipsel-unknown-elf-as +DU = mipsel-unknown-elf-objdump + +OBJS = reset.o \ + giet.o \ + isr.o \ + drivers.o \ + stdio.o \ + main.o + +CFLAGS = -Wall -mno-gpopt -ffreestanding -fomit-frame-pointer -mips32 -ggdb + +GIET = ../giet_tsar + +bin.soft: $(OBJS) ldscript + $(LD) -o $@ -T ldscript $(OBJS) + $(DU) -D $@ > $@.txt + +reset.o: $(GIET)/reset.s + $(AS) -g -mips32 -o $@ $< + $(DU) -D $@ > $@.txt + +giet.o: $(GIET)/giet.s + $(AS) -g -mips32 -o $@ $< + $(DU) -D $@ > $@.txt + +isr.o: $(GIET)/isr.c + $(CC) $(CFLAGS) -c -o $@ $< + $(DU) -D $@ > $@.txt + +stdio.o: $(GIET)/stdio.c + $(CC) $(CFLAGS) -c -o $@ $< + $(DU) -D $@ > $@.txt + +drivers.o: $(GIET)/drivers.c + $(CC) $(CFLAGS) -c -o $@ $< + $(DU) -D $@ > $@.txt + +main.o: main.c + $(CC) $(CFLAGS) -I$(GIET) -c -o $@ $< + $(DU) -D $@ > $@.txt + +clean: + rm -f *.o bin.soft *.txt core *~ proc* term* temp Index: trunk/softs/soft_transpose_giet/bridge256.raw =================================================================== --- trunk/softs/soft_transpose_giet/bridge256.raw (revision 620) +++ trunk/softs/soft_transpose_giet/bridge256.raw (revision 620) @@ -0,0 +1,869 @@ +^`q‡ÄtnjƒŸvdq†ÃæãææâÎÞáîãæºÛǟ‹–„Œœ®¬Ä͉l—žŸš«Æ¹ž’šŠ¯ÄŽÌ«ª¶¹ÅÝÀŒ¯³ÃŠªŠž¥¥µªÂ°˜†š¯§¶­»‰„|Œ}œŒy–jnWOK`uŠvŠwgn +|”œ©pŠ·[– Ž»§„‚‹™¥³“’Šœ˜“•”š £¯Š€”š¥°¢£š€² ˜ž’{˜s‚ŽiRh‰ws}}º‚fy‰¬œ• +€¡ŸœÁ«œˆŒª”†“‰¡Š†’‰|ho€xŽ ‡mpy|‚unh}liOTWR` +‚e`lX~vwgu +zn{~Q{y†‘‹k[}x™À‡l|„“–nfp“Ãäåâãâ°ØåçÝÞªÒ¶² +ˆ +¢©²Å·•xžÇÅԱž“£®š°²Žµ§©§›Ì¹âËÆÈÆŸ±­»š®œ««€§›ª¢©ªŸƒ˜ˆ|n›wyiu`YUU_nnv]Œˆ†‹©š~£rŽ§[t‰·ÊŲº¯°£ŒÊÄ°³¹Ÿ²«œ˜Žkziq\_S^Musk‹€“ŒuVon@6JI,0„FEg:erafXA +‡k±›«°š‹Š€–u]Lp‰ +ngQOS?MfY[qnvbcvNILE]NQQULZnk\jZVRK[gŠZHer}pqsYV\inWwzŸƒs„¿œŒ‰bl•ÇåäãçæžÕãâÛ݌ޯƒlm{ˆh—ª®’ +Àªœµ£žŠÃ˜¡º¿ÁϕœŽ©ÕœáÈÖÓÁžž¬ÉšÀ²®‚°’ƒ±Ÿ¢¶­—„œ€«‰es‚ƒ`tYKUln +kwve}k¡²‚‚ ƒh°aa“±Á¯Æ²Ÿ¹€¬µºÇÄëš³©•“}ehXXTVTUVf[[ƒf{€gO[M†q0=037 +FXg>‰šGTru}‹¢²yˆ +eiuœhd_[`}sZffbZ`6PJjhHk—gaYR[g`IURVDMYobQTK8E6E`cltj`€ntjf[WefX]dš•€zÀ·±®jeÎÞààäæÁÙßáåâʷŘlreck]¡ž®›Œœƒ|֪Ɣ™Ÿ”©Â£­¥””rƒžÂâĊ¿ÖŸ§­©¯ÌƧ¯§°¹Œ­¥ÂŒ±™ª ¡ ¡ivt‰ª–WOYegxqŠzŠbYƒ‹€x}}\—„†šµ»Âº¶Ž°ª©¡™¬Žwƒ™À»šuVVSQYGYkYZPjœwefrbˆŠ\&GE3sSBLFd{|a~š‰š¡®zZ{g“š€eqw‚fULlQS€u?DLz]El¢€_RVZ_]XQMXG;EOa_MSJEL@UJDGNDIJ@6>PI94Y\OGW;=L?@^K›snMZ_P]Wd|­Ž„­²„ƒŠxhŒØáßß×ß¹×æäéç×ÔѲ}}t‹Ÿƒ±{ˆ€ÍÛÀ¡®£®¶±›Ÿ‰l›|ÛŽÔœŽÂÉŽ¡’¯€²º¯±¥Ÿ‘Žš—Š¬–§e‘Šptž¢hKddqkn²›–hfuzjfrkwr“–£Ž„¡Ÿ§šŽ„r•€šw­”hBkƒocVag^bYd€Ž–pwvbem][U~PL+;>lraJ{4@bŠ;uxF@2YwW_um——kekI\M[FI7TJGkelWinLr]]Oop{—Š“ƒ~ŠdS:EefXRV~nF71SDKWE\NBXJO>]Vc]q]ey£»Ÿ³‘qboºÌàÔßä׳ÕæàÙÎÅ­‘q}k‘›¡€’|rz’„}‚Àž«²œµ­’’™Ÿ”ž¡‹ÖØÐÈŸŸŽªœž¶€«¹”}Š{w„»‚–|“y‡œ˜kJuzQaqoše™`gwŠ}~PCFtwoiMl‰ƒ š™˜£¬Áµ[wŒw|„?:eP‚|\XTfQUGLirmmŒtƒstLLJsƒIy?.K0=GƒmC‰XD-cy`–t‡€fPYtmVnxG>A>7dsNg{Œ]XRdhf`[v—ˆrfsA=A5UILIXh[Q02>BbMST?EY|kyz]RPQp~c”£—Œ±ªºŒXatºÔÒÔÝâå©ÌÙ·£‡ˆ ’zixwžx‚nsphq„ˆszВȻ­ŸË£‰’‘{º•³ÎÑËÊ©š£¥°”š¥~Ž—yw +R”‰‹†~‰„‘wz§©šuPdƒKZZzœx[nNLvŽŠ‹oZ_e`i]\lqg]®ˆ‹®›’„³§x–]T=?OymEIJKkJKEaaszxev|_To]e„f‘iI]bIU_CHbeYœ²­œhTT†qZzdU;BKNIYiS7/09AZHW5Ay¯q¹®vARtzBpy[IFGGGGVJPwf]XKb‚‡Š†M„keMBIJHZ]LadeJ4GN@KX^aj`|h\UjHbrigxœ ˆ +Œ›ujxr£ÚÆäØÛßž¡Œ{‡¡­|§l„gftz^ZHrȍŽn{—ϏŠ×¬ +}£”|lš +~ºÆÌ؉”a›”‰€µ›†`^u +hNW{ˆ“Œm`x|ŠŽz|©‰}•ÐuvyrSIAZZ€‹ +˜’XƒzXBXQewpn“­ÁœÄ±ªkpŒ]aC3:7AcTB:.p‘¥ž¥¯mAROeMSXkRFMIK>XIJxeb`Lk€—}dt\nU>MRYcgUjKFAAYTPa\JN™a}PRY`‰‚|hYµš²ªq€˜wn’~zgqØÇÔÞÞמ‰ +ŸŒÒܱ›±©ˆy|q_e~°¡Žƒ š|²Ç˜Û˜¬~i‹ŒžŽÀ”¶á±¥ƒ€lˆš«²°Œlkc—lNV{ ‘˜|o|g€ƒ’­‹vm¶ŒvxƒW_VX„lh +ž¢hž„ÇxXPMdvytl˜¬—£€Ã£ ‚|‹UG17AHBECE7>?CNXXKOFh‹T{e‚›ƒž¹uW]PL>.6PP:@X_Xe ³^gnQJUPTTY‚ULaK>:OXU`bZWfƒs–ŽjZ{klEMQPQYoki]^S^TLLFOFpdvjb\nxrZdٙ›ž~•‹ygœ’ugf¹ØÝÂÖÛ°•| Ô×Ñßᱡ˜£}xkhy€„Š¢‹”œ©q’¶ ÎÒ~›«•’š£»ÅÕáÐÇœ£˜®º®»’ŸržJHYwŠo~ +_ssˆ‚~ˆŒ¢©Å—kSG]i‡]V{ Wn‚¡o§›hZqrv`r\—}‰Âgtš·z›eNebVQ;GyHleEH`lM\]EIDIN\\PQ\bQfP[egQQLJMgn‰RNMJYXABW_ueVliV[YVSPIF;Ui^_\wsshZ‡¶y`¡£­r”šžƒš¯hXœÖÝÆ£ŸÉ³»ÞåÛÎ×à•˜Œv{~dej‹†Ê§‡ƒ‹‰wd`i‰n¢Š~‚‘s„È­œàÕË«¹“²À»°§{€¢ sxhrŽ†‹myrm ”mc„s—ˆ¿kg`ZH\UFGMRLc`Y^L^bnxJ=Ud[USu”LKGU§š:eVˆkD:613DG6GOFDDUHVNKS_muŸŒ¥¡›‘nf—ˆfcMfkC[Œov]P=5Eip\hd]j\uXTca=Z^wH_UL[c_cP\UQzVnRY‘KFDUZngXU_RPZUII?NT[KIRv_gRvgvŠ‡pšÂʊ˜ŽŠˆn~˜w`g–ÃÉ̎­»ÈÝæáÌÏÝ¡”–nˆtacƒˆ•Î­ŒyŽrYLW‰k|sw¡š’‰†‚Í×ÉÆÀŽ¥·Æº ²¡” ‰xqg~”]€ox‹ph‘v“‚uif_JCVR3@MS^YutUc§ºˆZlYi?Kt{c\_2eb§Žx]Ž˜P>?8<7>3HCJHUEQZGU]jj¢ÏÄ«”[UT~k +ž’UXfUZUiacPBYjeygPSWS`jU[¥€bIYhc[VLaP]_Pq^AO{e`a’aTXYZ^rdaZOXJ[BFOPXMEK`WWe +]²Œ€„§¿ž—–©§no h]b‡££¥‚kižÁÖâÜÔÙÝ°‰Ÿ¥–_Td’–Ž—‡}|RZb|s\{u|‰—}n¶š–ÔÖӻŢŌšš‹£³†{‹pqk‰“¢do{‚“{lzqˆ_XS_NUHNB;4@WnHTKSw~«Ô—ˆUKP?N`~bB?13jb”Zz’pG743>FABEDQTDQNGQX`|¯Îœ·Ow‘ +¶·€R_ESDA[QK`Wt‹UqyaLIEXc`Riy‰FEQ`^CBXWR^PhŠcfos}ZgˆicXRLK^eiSQSGSRQR^ZT=RbgLJyžŽ‚¥‡s¥°z‡ƒ‰d‚ž™uYcnqujljg}ÀÖàÜÜÞÙ¢o˜È¢š• “y•“uŠb„š|e}w +ŽŽz—§o€ÒÒ¥§Œ Ÿ²”›”œ’l v”u]s’°h~Œ›kgr—ŠW[XKLR@VLDT6GIDBMVŠ²ÖµŽsAKR:S[aK:-q[LSVSI{}DA<=?B?@D=LMLWU\TZaŽ¬¢—h +±vŠ‚Š·€t\Q`HV\^ivRnyfTobKDVROoL^m{MDfSJ?aWXjgbpxlnV‹bhkxb[_RM[Zf]aIILC>@^MURAQ[qHYScPyŠsRŸ›‰tr€Šm‰tS`qq„rr‡ÃŽ®ÓÜãäàٞvŸ·«—‘œš–m€rd`Ÿ·–ƒ^Zar• –š¢¿¶„‹·Œž€ÀŽ¯Ã†Ž‘ƒŽ^snxq–•ºt„ƒšˆbbc”Š\f~jkZQgUF8gxwk`~_VTHP_JVGHPAHBRay +z„qfwoWKarb}]Q[WPDOG\ITe`PUJEEYYHLD_‹yfTtao{šNT‚gab[rrkt˜cgTdm™ÀóžÚ£ªÎ×åäßܯ˜™›©œ“”†‚m‘xcˆœ°šŽmaco‰‡žÆº¥¡‹–ŒÀ¢±œª®£šž¢‡Ž—|mrc^w©Ÿn‹ +‘ƒeru”m^[Zgnskn>bdJ3B]kGœËÉÉÆÂA,6;;Qm8dKMRLKk]\ºÛÁ§Ò¿T)?JKRHEEGLSOJDYis]adfp`†lp^W ƒDOWpr€SAIQ‚mœ®—oBLG2GFSFQQU[Xa]QxeAHb]TBDH]UOGVMQ2=SVMKM_nRkVAbDWMH\c]hTQcnƒ{ƒ’ra_uV\luXonXUqžÑßÛÅųµ°ØæåäÙÚ±ay£ˆ{q’•‹†}™µƒ€•oj +ƒtfŠt»”§£°›¡ÂÆÊž«¶œ© Ž£ª¥¬­«¢nZWt„k~€d|y“‚‹ijjdQOCXFAEW[ZGEY^WGÁÇŒ¿ÁŒY)6BQSoYdPvcc¬lBJTQN8IHB=?CPFEFEOXQSILbkqvRc{¬Š‡ªq‚Š©cJa;5G|—cPT]‚Se|ŒB7AKLSMVW_TJXLK\wqBMjKY:NLQRBSKHJJYKHFLFT\bPU?WGknP`GWS^IiŒ«Œ¡a|o‚TYxqX‚Ž^YnÃÎÕÕ÷­ŽÈÐÞààÔҁbgx„pe‹”“z‹—”q„zfm‚’’€¥·œ +³‚Ÿw®ÓÖÀ¿¬¡Ÿ¬˜«µ°ª§«™­ˆ‰‘^O’†lƒ^hoighZ]VgMHCC;><=6CMX`PD7EYU@AFaPWIVE9SOfzv–ºŸ’’‚” ZdKKVcLyj\zmvD^†gH?;>IYbFLD^HFIKKFVhCM]VMCQYXFY<>RK@@MESJYthfKZ]e‹}mnUEYWNuvx¯Ær¡k‰k\~kjm{jU~ÑÆÔÛÖÀ«±ŸÈÑÜåÜÐraŠ}©¥{–‹˜Œ€™ +Š‡tftpŽ®šŽž™˜y˜€ÃÜÀÊÒÌ·¶º™¶¶¶—šž€€ŽcpYgœ€pf^[a[Zc[VZXVGZBA>mzWRIYQQMOKoVNI@A8o„\dflžƒŒ{t†€}USVFDU +‡Ykk}[GCQ=FARoXW[KYLIƒpL?>b\[PGDD4s‹]][U<:XHMANDo`[_cc +_XX +nrP]Qri{«„c”ÅŠ{f„zglaiidbWŽÑÃØâ×ËÁ¯Æ×ÞÙÜàÈp] +s„xx~ +™xx‰‘x{‹™²œ³š¡œ™›yŸÙ×ÞÛԱźŠ¬¯®«®©œ—“elq +”¬†kyvkakilmV^\QLA8@:Kh`Ux:;bBU}Š«³Î»µ|—agjcXcz›Š¯]F‡HMfKE?Mn~ƒ¡’n‘ÖĞmjtvqo{jT_gZ–ÉÜÚÚÖ·Ž¥ÆæèãÒÓž|}qxy‹ +{’‰‹we‚œ~v~ŸŽ—ªž‚˜§¢šˆÅßÞÖÚÓ€Œ¶Š¥¬€®ŠŠ˜”–nz ’«‘tpˆo_hYUbcVKOH=9<;==LmrCB]MN_W‘¬¹Ÿ°¬ž–‰ˆmpUZ‰X]PSJX[MN?MSSPS\C@R__UcYd„]dp„vf]‹“ic¡žŸ‚yon]VnObp—EaNaL0m`98I[_YMGbbOqCFFKHcXH=9]uWbC7EZMdSaTENRTF[FUQLT=7:S£|MJIYjn†”q™ÝÙvpxˆpWY™jUac¯ÍØ̜۟›ßèçêßƱˆƒlŽ˜•Žz“„‘dks˜‰fƒ—šž’®‡k  ‰–•ÂãâÞÛ׏­¶¶²¡š«ª¬ž•Œlz«¥©‡rcfZV_VRLPNHQKHPVYQVk‚f?B:=Oo‰¹ŒÃĶ•‰wxVoX^O`P_JML]\AOSdpQFLrD<5PPhKF[\WTF?OFLNABHC|‡_MPI]tv“‰ŽÕÝ``d’`Z]}|u]t[šÁÃÀŒÂÅŠæêëêåÌš‹§‹ˆ€“cW^q}q™¢’›£”““Š žƒy¡ÚãáãÙÏ¡­ž®³®£Š§§Ž£¢Š°µƒpineKLRLS`SGDHJ[Mxq€†zkH=A58Yˆ‹·°ª»Šfhk\[\N?I<@96>'#D7GA^LZVPhY\s™ua|Žžvv‘Ž™€ˆs\–w«—¬l}w‘ŒÅ̏?DSvªŒf{_W/C^CpeRQI_bHSKOˆgVh_S]CU]lTKRk\^VNK^SPQCOKD<5N]kqRJEWY\ŠxlšÉSoYl{femghaoƒÆË·ÕÏÖÒ§Éçêìåæס“˜Œ„††‚vX[]_b}Šœ›„Ÿ²šœ‰¬­Ÿ–{ +ÝáãáßȞ¶Ž³š¬€Š·šŽ|€_–š™jgxa]HROs}_AB9@QLw +ˆ˜sq +cE<4Dc°ªœÃ®Š}aU3TeEMINCKFE%1?CPQ^[VmyTSdW¡žŒžšw +”›—ª¬£‡“c”©œfO”}‹³É©j?am“†YeHkGuTbYXKSM\YDH^W€ €{TO@ILŒeVLKfnIC7WDXMPLZUGKEFF72;ML]u\LRS[umykk•—lgUmaŒsmq{nmÇŒÓáÝÚàŸÈéíãæäכsz +Š˜vs†raqrfcŒ’˜{®Áƕ©ž„‹ +iÃâãâ×Û¶«³¯Š€¶©«|šŽ]pz~e`tdQ\\wNJO=9;:=TYXGMfueME;GUš±ÄÊÔŠ’~bUQSQEK9@E.FV1,aMZwWNFSg\]Š‹«¥ª™pwvŸ¹¯™Ÿ¯ž‚m±©¯ef|zžÈŒš×¯;k‡‚bSMUIS“xMf_IA[csTBNŠœžinYODG@F]s;?O{‰D8JKF?Ebb]UN<4CGE@HHSCMYXVK]\^]ol²\cRdXov˜ƒli€ÙÕÜåãÖÞÚÜçêæäÞ֊„‡Ž uk‹¡„‚ttŠŠžz€’Ï»¢•Àƒ™’‘~ÃÚåæÙŸº°¶²ª³¥°œ¬••„L€Y€medi_hw‡`EB:N3=6:9L^UxdjJTU7H\OeV@MEQNGYape692HAHOO/@L@6>JPZZjZRY_ ‡wkxcO€lƒ‰riƒÝçåäâÙÞÖÞæçÛÛÙ٘z–©¢x§ž·²Œwlf†ŒŽ¢Œ±š“‹ŽÆŒ“ÀÒÛçÓŽ“¶³­¯­Œ€š«›”µƒ +ozYba\ZPXmW?<55=44E?EEbudp_M~i@BW·ŸÒÞ×ÃcaaOK_\ŠFcT;MQ;Q +’}i`m_|†‘ˆ‚”¹Á•ˆ\\nž®Šª¥ª¡¡r”µ—u‘—Š Ž•“nlZ^gogr[b­tGZ”awVT\`¶ÑjU{’qZIu<;4GNh?Mz†¡MODVhTTbOZkNK>PPX_865K==8GIHIGPV]d’\[]ZSi{‡„mg’áêêááÜàÒÜäãàÙÏ×€•¯Ÿª’§¬ž¥–Œ†‰y’~³ÛÙ¥¢~w—ÈŒ +†”ÆåàâÚ±Œ¥·© °Âœ–²©–£”d{mQLTKVPJGBFDB>4BI>165=G^OU^bFn;;C£²ÄÓ£‡stg\VuƒMFZXtn‚£†„|tq]snŒŠŸ˜muiv„cPLR†ˆ¢¢¡Œ²©v‘°mŸŽ‹d]z›ÈËǃqcgv|zŒrHG~IMQ\Œ€—u[krzyDHX==;IYJ6j_itNNRW`N=5<7IAEKILIDNTVWihubpV^jv_^Se°âééåêãáÌÛÙÃãÚÈȀ˜ŒŠ©‹““–”qk_rƒ‡°Ô±ƒ„ƒ—¡Âž™›—Œ€âççâ­u§¶¡¶¬Ž€›³·§|’VqrJOWa_RSO@VO[EHJE3/64E[ULJRaV=O9B•©µ¢hhogX`j +guugdlTrqVkto}yz”„˜ºŽ~]Z>\gOI?†—©µŠ¡ŸŽ„\uay›‚]o“ž¡ÆÇÔœVAte€v²ŒBQRaVJFL\tƒpKfO[ZCR6::<1;Kh‹[R‚”Žy¡Ž©Žš_^}m`KM`p]TW>KPN]^TQZsbNg~€uxjCIW;Z\€ˆ™€Š¢’t”£W·ŽŠš§ÂÇÅØÒÊr?NEXVvzKWU^diWBLUi\IKGQHNM>?73_oIW··bZF71[piFBDJCKHCKCSI5154;ESRXKWOVSRliƒNi{~‰mceobwÇÈÔâáÚàßÉÊÌçæàÝ΄‘•›§¡oˆq‰ˆ†€ƒÁ¥­r‘œ¡£¡ªœ„ˆˆ|ÚåäÝȐ¯«‰ŠŽ³ŠŸ¬µ°ˆ€io +J;nV1IHKAgHdXcRKJ88Hf™pJb•{žœšsp¬ŸÄÏÀ›xog~m_pdrfWIT?MIEQuiBQj_b[Yt•Š›h8Kr“^MOx·šš‰mº©z ‘Ž¹ÆÒØÉ°P‚‰‘`f\S\m\VQGF\DQWHCFoWˆbj[I=OH4£ÖºŒ@<8ao„T;:BRKIE>HTN8/45CDVIKJ]WJYYvSe„]¡sb]UaŽcØàÙØÁ¿Õ×ÖÃÎ×àØÓº‘™£†–ŽŽ›ž‘Š–¡•m•©„sŽwŠ’š—œšŸ” Ïàäàⶪ˜€­±Žº°Áµ—†p +wO6J8JqbP_hbƒ^qŠDG3PouYGYp]hŠ„_U +ŸœÅ²ŸŠun]}|rl’P^J?ODOSVU[QpZmd_tˆ†YUa€xVSKkŽ +ž| zqz†›³®»·ÊÎÉÅ¥ ±^FUdT}q]_\II\HfpP=CDFKjyveEBVE.“ÁЬ{8AHYdlUFAUROLC@@C_9.1??IMSAMYOJYy€PUŽk|~OuUZŠguÓèÚáÙ¿ÎÆÓÉàÜ×ÓЧš– ¡¯œŒŒ›ª˜•Žˆ—Œ’‹miš“’Š¥¯zxŸ‘}µÛäçä˯ž­¥š°®¶¬·»€’‰ˆMKDA=•c[Xv†‰ib8H9@n˜H]{r™†›žžž‡¬²±š|ukfS‚‡Žs¥œžsˆOVDQDQNXrinWbjwX–€Oc[gMORZšœ¯š•v]˜«²ÅŸÃκŽ›“•XBFLT‚tTG[VXQN_h]EELIN£ULnƒK7R^VI‹€‚ŽŒ:HB_]MQ^P??AJB43EBJXM7PLKTlqœ€xmq[ŒuQLiƒdmÓèåâÛÃÁÓÕ»ÔØÌÇËŽt~’—ŸŽxš‘~˜°¶Œjjf—¯©šª€ƒ•ˆ‚‡‰¯Ùæèâǟ®®©³¬¬©£µŸ˜–Š‘qdo6q•YMUcLo„now>OAS nut––eQ˜Ž§‰›£”qpddxw•¢Š‹foLRNlUZOifXWr†iftQn‹ŽZ6MoŠ“ššºµ„ºÁ€[¥«£šÇÌÑÄ¿±µ±f_9EX`tUHWe]fr[^P@RGG@ŠHFVM?F[B.z‰Œˆš8@K2BBME?0@D?J[UJEIW[V=R‡X_npWMJQ\wa‹ØáçèçÎÑÛÄ×ááßÓסv’€«Ë«”šŒœƒ„Ì৙mlg¢„x}¯™“Ÿ™“¶ÔçéâÌ©µœŒ¯›’§¯¿®–”œ +‚ +{5Ž}]V``\va_WSVMjx‡o_€³ËNJau‚¥šœ£‰wcaŒ•¬Š™Œˆa]GAFXSR[zx\epmTNtnrq^VYXebn„ŽŠšœ›—‘sŽŸ²ŸÂÌÓʯŒ·µ‘_YFQRbhygOXLwWTLYXBDIQ@]OXSCHDT?7Qj•Vj„99DU]`QR=C:MfU5CZ]N=:9GVLLH=NUiO+4y·Š\fPP9AFB\;>DB=DALF_o›bC4Bsvv†v~hc_€âàäìåÕÒŒ©ÑåéËÌ̉ƒˆs–¬Ÿ™ÊÙ㉧¶‰‹u¡¢qzž‘­»³º³ŒÕæåàÑŠ«°²ž‘°žš«š£{|€t]OQN^]dƒŒ€\LSPplcXX +®¥n[FO[ŒŸ³¹™~_Wp€¯Ê¢ÀŬ­©©‡ab^crSFQhgv_TI[?_[˜X<^di[{¢¥’‹ºƒc¢“žŸ£ÂËÏÎÀœÂ£|k{[fwYkWVfhhkaYY\RZAQSNSWejbNLOSyxŽœSL5:ÁÊ®s\R_:@EFIMP>TAFCN@HAIJUlp^UCA>Ud_g{ldeoqiÝãëéàÏÌž²ãêåßß̆„ƒŸŠƒ + ÓÛÞa\kpxuxššwg”y +€ŒÁ¶œÅÛçãÞÝ®Ž¡£› ¬–ª®±«€t™dmtcMMi¯‡€n]RW\glq`tbTCGuU[~–«¬¥¿®Ždwcˆš²­©Ì¯¡˜­hr_8:]hNJDauokdG>w}º¬L\fOW™™­„Œe¥±§¥Š»¯ËÉÅÂÁÆ ‹—fvJb„y``Qkpl_NUo\Qe_PZZ\cg{iYJ\[^d€™d?A8»œµhYeT5FmbJGGG[O?OSOVJC?RbR‡`RU>CPokna[\^gqÕäëèÝŧ®©âëáÓݘ–Ž‡™„mˆÎÚÒjY[X\ty™zrŸ„{y¥œÀŸÈÞæäÜÁ”°²‹‚š˜ª‰™¬±Žz~Ž¶µŽ~rj`X{—‹|QPM\YVLSEII>SAKKFŒ«º¿Š²—de +Ÿ›©§ÁÁ~†ŽyIZLV=ESIDE`UsoLWXmi{ª›CV~T\ƒ†˜‡ix‹›˜ª±·µšÇ¿·Á©’‡–O`‹”gwVmaR\ELv†\†hLLclTLpWRKmƒ[y˜P7b8‘¥µ“o©qIR_KYHQX[NKFPPhG=QKa]T]YWUbiY`dbfX^lž°ÆÓéÝŒ¹ÉÍËÙÚÚƬ•˜¡¯€ +­µÚà¬cZY]`]n{€€‰†Œ¢ÁÅÈâèåâħªº®£­Š”²—£”€£Á¬‚˜€Šxu{VTJ_MVKPGeSBF=BWIIzšÃŸµ”®€ƒ€‡p’ÀÞo›ŠdNBHQI?KA:[dh_DH_‡{ƒ›ÀrSoi€ŸƒqWn’—œ›ŽžŽŸ¶¬­¹ŸœÂ~®¡§‰cLy˜Šo—IYdDSQNXNVƒXT[€nK?TXiBgpF„eŠU,GJ +Ÿž†k‡RZPQKp”a[UJ?BBJXVISLZKOPNGf^c[Rav`adh„ÑèÈÚêêßµÛÙÛÉâÜÉ¡–‘˜œ¢›†|žËÃÝÜ +[VU[hvjdŒdlyvoyœº·Øäå嚯ŶŰÁŽŽm +¯—§±µ‚xŽ«„s~Š£ŒycSHGGRZcƒ]\CU[\`@E€v¢pš²¬’™}ˆ’ŸŸ}d²Š‰R4HbZABMaQu`kiaNŒˆ‰ƒ¡r?[t¹ŠÆxŽŸŽ¢¯©Ž­³Œ³Ÿ­ªº°·›¥”±ŸwLOfv­¥\hŸIU_uYUy{ug\™ +i=@VoDnNUŒTc7%7V–¢r +†€€‹gdvzXIBTJHMFBRFKOCNRIRLMR\RRbdeox×âë¿æÞß¹ÍÍÔ×όț‰Ž–š‘¢ŒwËÚ»ÒÙÍsXSb”‰i‚bYjjlŒ†ºßåà䘜«œ‘™Š€u²€¢¡ŠqTx¡v“wŠžœuiUEI`ISohciQH@C>YklsW„”®À›Œœ’žº–—˜‘„Q2Q]F\Ynmqnf€rSVfZha“Z]O€¹•y›˜–u«ÁžŠ¬³žŒ¯«–~µ¿»¡»§‚KPLi~}k[jSTU]||~[mPa« ue>9cHLk_F:W50*[ª€¹€‚«¬¡|kSyiLY^Q;TGQE_LI?KEELUXOVNUS`o~w‘ÜçàãœâÜÌÍÀÐÚÓÊ­žŠ”’‡‘“«ÛÔÚ¡àà¹enytz +hZO\q‚¥œ˜Áàæãካ’ +l›t’}™šž«ŸYyŠ + +ª±Œ€‘oye^w~YeŽœ¶–T`HBHPGNWLy¢‘ž³ª—®º“«±ºf£rp‹P4OWBOZg^[zwšGJ‰d^dGŠcf›ž•žše©hkzšŽ€Ÿ§€Ž¯Ž­¯¢š—«€³ +Zk\Uƒˆ‘_UYPBa‹ +i¡Zb_S‰wNa7AH[ƒWbiƒxq€hvwSƒ^>jor€µxn“zšœ£¶©ž±©€±¿­µÆŠyz‰oŠVnVŽ‹šma\DGcšxurVbTnigF/WGLTŽng’K=02AM|v„vt€ ¿Á‹SRNvbc@XLC[eH>Q[T=@VRRm\\kkgaQ]iuâêÞëìãŒÓÿÿêâòðП¡©‰š® +™Ž€Ýáۈ€Óà×{oxŒffi``cZbs’žµØçéå{ff^†v–„lŒ™Œ‚Tn[z–™œŒ›œ£fJu‡{p^Rf”Œƒ˜ˆ +¬¡€ˆsav‚³ÈŽ­²šy‹œŠ„p3HpM=B=F:JQj^bfz]‹‡œ‰bŠ‰_I[qu€¬š­ŽŽ‰ ¢žž€•Ÿµœ©£« ¬¥wpVTbž²€~_nsQhjRRRU s‚}faFRC<@7DAYZ`„g‡GJ7IUQŽ^m€p­Ž®s^[iiKb9CCI^`MJAPRUIFEUnf\OLRd``z|ŒàñòìÛãáüçíòõûü÷Ȕ‘”¬«£’žßã̀{ÝÞŒwqŒŽuve[\ej‘¶³áÜè眂‘i—‚˜‡jl›—}›}|•ohn•fq–xez™—“{S]žŸŽ†®Œ®µ» Æ²šy”«ªÄ»Ÿ©¡¡‡­—i\NGPCB>>9;GDQfœ€‘”•UT[“EBY<>AT`YSJPXPB5AFJPE`VQV__^sv§åòïìàåüÿýàÑà÷þÿñ—†š³¯ žŒàä¿rvx±Þݏluec|“†vzv†o¥¹ãÔä瘔™†ª›|Qj„k§’~uf‡Y–i^ƒd™}ˆ_T^Zx|™”©ŽŒ»·Ÿ wŽ ‹„²Ÿ»€•™œy¡•’pŽNOJG;:F€i[†ZŠŽXp^[\–nnšfxs¯ŽŠx +’s”Ž›€s[Gu^ƒs\pSVJg”ždVVSTUqƒ™HKM:2@;87-?bŸ¡SefY;@9jpTpVdœbm¥QUgOyw?HN\P_bNHA622:1, +18@k†TLEAC;=k¡–bqFZTjKK[cQ:Q~INRO[]vX^K216CL`€¬©«ªµž¢Œ~x áìôöôõþüùýüþÿíæã쑙Ÿ±¶ªÓàæ}mr„¶œÂˆŠƒ}†Š•£Ÿ~—£»×Þç籒§Ž®º³žapŽk€qyMb‚¥’‰yOstpy\€”†sy©˜¶ž¯®ŠœnŒœ­œÄ­µÃ²¿ +aŒ®Œ—rWRWKNBQYMBL<;_ONMAHEUUwš +yqsxgmSDRhu‚¹¶š‹ykab_lzjOOGJobUBA@PBw‡ž’XYAJ=7HI6tm:22:0PhWX[}T_74)3D¢mQUIIGDWQahW:D=;AaO?KA_VNSP96>Q[SUdXWZ]`benžåéò÷õóýêèöéãíêÜØš¥¢Ž‹Š¯®ÜÚâ›xx’oŸÍׯž“ŒŠ„ƒ—¡ËÛÚåç·£œš±º­³cvh†Šp_~ˆž™j|ƒKk +‘kt€‚‹ƒœª¯ŠŽ¥¥˜†Ž£ŒµŒ¬Á²¯°KU’­ž¡sZL]MCCXqP=;>NqT_>p¢©kRNLB1=@FVNTB,(J3zŠpRWwbsf85>N‚j\9C895KB=/.EIKMX76DMSFHI>A@>RUSWVUUWX[]bhšáïòõïßñöøôçîäêîñƺ¶™œŠ§›ÎÑÔÊŸ€wtxzË×Ü¡”–š”ž‡ +˜ŒŠÐßÞê韈—¥ŸÎœ»”lv›yg~Œ‡‹˜h{[eaiScld–„¶¯£¡¢¥¬•msª«µ¹Œ­·­ÅšePžµŸ~{]LIFPWa€W8D@I‡rBBIKMVYG^b‡ƒux‡eelpj‹–™kePeutzSNDKBZ‰pkL=:_RL_qzudsidxZNZ€|itŠkj{LNR`\QD?E63FLWB>;CFUnTN>5FZF=8?V10G,CKKpˆ ŽQ(-5OodbO.7K[?AgGT9J[iF8ACHI}”h]X7LLdLÉÑÑŸ®°ºœŸ¡nªëëíòðÖ¢Ïþÿùùÿÿö·‚‹¬š¬€ŠÅ×ÐÛÔɉ‹ˆˆ™‘·â㬃™ šª—–ŸÈâãèß¹ŸŒ¿µ¿¬¹¯xV~ž~KK}vZZ‰ycOIP[w¡Ž¿šž€ÁžÃ¹µ«ŽŠ“¡¹€¹š©«Á²¢~­œ¬‹ +^R[CDLZAOXOOG?I<=?17AC1<*5G8O‹”xRC2J18?V‚eIUYUxSlEU_\JB:5XRJIaSdpU[YDGÉÎËƬ±³¹¥ˆq§ÞìîñòߛäîìäÝϪ|ˆŽ­”Œ‰ŒÅÑÌÎÞΓ—šq‡x¢ÜÜØ€¢•œ±¡ÄÑÛêäÛ³Ž·Ê¿»¹Œ»“‚‹˜šjŒ„h_Z~p[NVnŒ­€°¥­µÅÀŸœÁ¢š–ƒ¯Ã°°Š™›µ°Ã§®ÔÒÁ§—¯yprb>HCPXHblaBIb]SYavfLRF=@Gh’nAVof[bY`j\W›x_VMIID:=A>C>8:D>7=PSVJ>4BI?EBF<0(#+;:e‘š~Y3C;B4kl‘ZKHMV„|[b[W{wd27KYKMfdZ`YYZIWÄÊËȵ²Ÿ·©wrÄéíðññèÜìéêåÕÛ×ujz“¹©—©ŸÍÛØÙßډ°u™xuœÞãË¡¯ Š£­·ÔçêåÜðœÌ¿·ÊÀŸ¥™’·°y€‘sttˆxXKQq‰‘µ­žŠžÁ¹ŸœŒž±Ÿ§ŒŸÀ£ƒ’©¬ Î§­ÍºÉ··—Ÿ‹o|iSdW`XtZhKRYri»^}¢cJ;:ERt\P_ZVP_enZqw{ceNRL=DNGBAC::@8:<;+;@?MV<>=?PPvn]l6LNJ;76MCI978DO^Zps@FHEE?.8@299%(487scjREB3TYuz||]AfZ]‹ŠŽ‚jnKŽN)3@Q3[_XRLCRJÂÄÆÈÏœ»ÊµŠu®ßëéòôëàçíéæããҒ§ª¥€±¹ÊÙÜØàåàÐÁ±²±¯˜‘—›œµäæ໳§­¿ÏÒÎÆËÄÀºŸËÚÈÄŸ¹®µ³Å»¯¶˜–u—ˆÇŒfŒo†³œ¿ÅÄÉœÂÀÇžµ·«º¥‰š‚©ÀÁɚ‚Špu¬ÀÁŽ`qqwi}„pŠtnbqhz{olwks|‘r„ŽviYU]lady~}w„ —|zzƒ‡••’Š„ƒ|†Œ~‹H7,8EPl„kPVX[K75/7@A7&0B?4FDDKI&@@Uk]\rHPuic‡ +‡uX‘—‡k**SFEb„vQmcaV>QÁÄÅÆÌŮű„u°åïíóòîØéïêëéèՔ«š¯®²œÍÐÙØÚÝØÙÕŸÁŽŸ»°¥ž—£ÏæåƱª³Æ×Ýáá×ÐʺŒÉÈÎƳŒŒµ¶ÂÀº¹©¢Œ®ºÇ °€ƒ•Œ¿ÇÌÊÅààÉÅÀ¬£Œ•gŠ®§žš‰ª³®ŸÊ—‘—‰‡—Š™ © §Ÿµ¹œ¿ÌÈÅÌÌÎÉÌÎÑØßêäåååæãåâæãÛáâãââããããåáÛÊÈ»£ŸŽ›Šš¬O-1@=D}gYUJbeZJIYVZejTyZD7I:LT9=@A\kY\[DQbHsv‰}uŠ¶‘ + +25AKU–gfŠ‹€jdEI»ÀÃÄÉÈ°œ«‚vºäêðóóêÝëñíïíÜӑ£«¯¶²›œÍÓÖÚÙÕÖÓÙÙÙÖÑͿƌ²ßãä¹€±ÄàãçâÉÈÌÃŒÂÂÏÆŸŸŽœ¿ÆÌÇĹ²ÄÝÈÂή‚¡·ÅÒÔÑÍÈÛÖÓÓÌÆËÈ·°©¯ªš±žžµ­ÁÆÎÓÚÝÝáâãçäççææêçëéïóñóõô÷ø÷öòôõóóóïðëìêêæåáÞÒÒÍÍÆÇŸœœž··Ž­¥ ’Œzrufl‹“Œ›€ ž‘U€•¢¢¢ ¥£¥¥•}JDIPS\gVRd‡„•w“œ{¡¢”¬ª³¯ +²®­ŽŽ³±o›±Ž‘†OTpT¶ÀÈÇËÊŒ®ªƒw»áçèòóíàçëîîíÜΞ£žª±§ÁžÍËÌ×ÝÞßàßßÝÜÝÛÕÚÝßáÆãåØÊÑÎÐØÞÚÈŒŽÁÅÅÍͺš¥¡¢¥€¶ÒâìñðïíìðíäéìèäâßÝßáÝäääääçâÛØÍÈŒŽµ·Ž»ÄœÆÄž±»ÂÃÂß»·Ÿ¿¿ÀŒŽ·¹¹Ž­¬¬ªšŸž—”Š‡‡† +~}}ywursqonmmlkihfeeeh¡ˆj^Ip“¥ª¬­¬ªŠšF +¢œ¢’€¥¥¥ŠšštÀÉȹª‰š¬¿ÃÃζʛ¹•­º®Ÿµ±ªy§©¥€¡ ˜hž¡˜šœ–œ“¶ŸÉÊÌÑÑš­ƒv±ãàÙäóçÛèííäæÞÍɹ³ÃÊÊÉÊÖÖØßàßäâæåæéêêæîìïïííííäȟ¬ŸÄŒ¡”š¿ÈÎÒɹ™Š‰‡‰ˆœ³ÂÊÑÜÚÏÊÎÕÐÏÉÀŸ¹µ®ª§€£œš˜“Ž‹ˆ„€}xuuutssqrtrrrrsx||ƒwƒ‡†††„ƒ~€€€~~}||zyyxuwyxwvvvuutttspppoooolnkmmqŠ––uhŠš«®­Š¥ž›L•š––ŠŠ Š§Š¥ˆši°¹¿ºž§®­žÊÅƯœ·‚»Â›Ÿ»º†šµ²±³²™cˆ€«±¯™°±±±²žŒÈÌÓ×Ú¶ž‡w·áÍáçñèÚëçîíéëêèëÞÚßæáØÔÒÖÒÈÅÊÇÅÇÁÂÁÆÁŸ»»³«±²¥™“‡ŠŒ€}ztwxzzwurooonnoruy}ëè°§±»³š¡›•”‘Œ‹ˆ‡ +‚‚€}|{yxyxwvvutuvwvvuvww +ˆ”‡ˆ‰‰‡‡ +„„ƒƒ‚‚€€€€€{||~~~~~|||~~|~|{{{z}}~y~~€Š›— +˜¡šª¬««©€¥VŠ“˜Ÿ¢¢œ©©ž©ªˆ®jÄÈ“žµºÄÇÅÕÒÏʀ†§®x¹¹¹Š¥·³²³Žw}Š®±°±²œ±²³³µÁÃÉÌÔ×ÛёŠyºÂÕÝèôôóôðÕŸ«¢¯ª§ž›——’ŽŽŽŽŽŒŠŠŠŠŠ‰‰‰Š‰‹–”˜”‰†‚€~}{||zyyyyxwvtwvuvwxz|œóöÚ®œÅŒ­£œ˜•’Œ‹Š‡ˆ†„„ƒ„ƒ‚‚ƒ„ƒ‚ƒ‚ƒ„„„„—•Ÿ•™Ž˜”ŽŒŒ‹‹Š‹Š‹‰‰ˆŠˆ‡ˆˆˆˆ‡‡ˆˆˆ‡ +‡ˆ‡ˆ‡†ˆ††ˆ†ˆˆˆˆ‡‰¢—›˜˜”¡¥©©¥Š§¥££Z™ œ”Œ–¥¥£Š©œ^Ç☟ƹÆÕÕÉÒ×ӝgƔbºž„¥¶¶ŽŽ­n‹²±®²±³²²ŽµŽÈÈÉÊÑÖÙÖ­„|»ÙÓ×àùúù÷øìﵩ¶²Š žœ˜—•–”””“‘šŒŒ¯™¢˜’Œ‰‡„„„ +„ƒƒ€€€€€€„„ƒ„†ŠŸðøú¿ÏÐÀŽª€žœ˜”””“ŽŽŒŒŒ‹ŒŒŒ‹Œ‹ŒŒŒŒŒŽÀèæéÞ¡­ š˜––”“’•“”•”•••–––”–—™šœœ  ¢¢¢€£¢¢ŠŠ«®°¶·¹œÀÁ¥˜ž ˜ŒÒÒ¬žËÊÈÃÅg¥ÐÏÍÄœ¹ÇËÇÆÍÄŧ]Á¢ŒœÄÒÔÒÅ×ÆÔÌ̖†Äƒ¹º£º¶µµi›t¡›‘¢¡€–®š¥š–ÍÌÌËÒ××ÕÀˆ›Ãåãéäùùø÷ñãó޷Ź«§¥€  œœ›š™˜˜˜–˜–˜–—­ôôí¶œ¥›–”””’“““”•—–˜˜šš™™™š£§­²ºÁÏòøÿåçåÞÙÖÓÒÒÑÏÏËÉÇÅŸ»»œÁÃÄÆÇÈÆÃÃÆÇÈÈÆÆÈÇÈÜëëëðÝÝÛÙÑÎÉÇÆÇÈÇÈÅÇÎØÝÞÞÝÜÛÜßäæéêëééêèæäßàÝáçéëíïñòóòª¢¥Þõôñ·‡ŸÓßÛÕ`°É¿²²³¬•±­£™“zQˆ]|uytoqfe[qf[Klpmu[\{efUjW•|%+?špg‚x›„]ˆeÑÓÒÓ×ÚØÕŸ ®ÄééêêääéìÞáïøÒÀ³³°«±»ÎÒÌÅȑ›‚±¬š³‘ŸÇÕÆÌ÷÷ûџ­©ºÛßâÁš³ÆÑÕ×ÙØ×ÕÑÍÊÄÆßßãéïñóõùÿý÷÷÷÷ø÷ø÷öóñïëèäÞÙ××ÛßâåæäâàÚÚÜÚÙ×Ö×ÕÔÕÞèççîçØÒËÄÇÅŸÀ®¥¢ ¥Š§®µ¹¿ÏËÅ­šššªš ¡¥¢œ’”‡‡ +„uxrehotm£™ ŠŠufVSW_WŸšŸOIJHOcF<60-A;(5&!(2-><[K<>Lb^LJ`W[DAL††Q +H_rŠ”wt}Ÿ +krYÚØÙÙÙÞÜÖÁ±ÂÍíïëßÏÜÖãßâîøçÁËŒª«º×ïëæÖÖš©¡ÈŸ³ŒÃžÉäËÇøøü奭±ŽžäãÌb] +ˬšÏÒÉÅÇÉŶÖÛÝäçèëöúÿþãêäãæäßÙâÓÔÐØØÄÄÌÊÊÏÍÐÍÁɬŽžžŽ«²±€®µª°ÎååãîÛŽŸš˜€­Š¹‹[OLPXbV^\ƒµ²ŠYPQHGFD?QPMKGFC?FQQMF?@CBA£™ ŠŠ\=LIRTd˜œœN@HI;7E;*-]M>.,1="$!.1;BZF6QWHJ=@IX?=FgfvZTR8¡¥ +we{]\eMßÜÞÞßàáÚÈÊÑÞêîïÜÖÜÝãÝáêöç·³¥ŠÄãïëåÙÙÑÐÛÙØÒÑÖ×ÕÓÈÏù÷ü㪢 ®œÂãß­]c±ÞÞ¹œ¹®ŸÅLj~©ÇÅÆÕÜõùÿùžÇÂÍÇÔÇÈÏÅÀ»äÍšžÌáÔŸ¿µÂºŒ€ÃÉǟ¬±­Š»ªŸÉäääî׹а•§›Ÿ¢ŠvxwtbZ[\—ÚÔ€^UVOHOLOPVB?DAJGKFB9GGC9BA¡š£§©WADNEKwåْP<>7*5>/$+F85 +&>&&0 + + +<=:'7K3EDF<8;/C?=Bb\dj?)+š§«”wTegY_Táãàâäãá×ÀÊÒÛêëîèÙØáÞßàíöÞ±§¬Žª©ßïëãØÛÚÚÛÚÙÙ×ØÕÕØÚàûùúïÈÊÆŹ„ÑãâV±áÞÉŽÁŠ¡·»Ã„u}·ÂÊÐÜ÷ùÿúŒŸÀŸÔÉŽÄǹÂÂÒÅÈÉÎÛÌÆÇ»¹®»ˆŸÖÛÙ¯š¥°Ž¿¡˜Ÿàáâï˕›œ’«š ®§›ˆnn_iXdU•àæœuf_PNPKMEPHL>BHTA?H=C>7@RAšžªªQF:F?GhæçãÁUbM7;@;'+*A&.8 +3%)(/ +28>B>S,CG8;HN=:7LPXidH + '££•†qkcJNJççåäãçãØœ­¶ÖçëïáÇÉàáèâíøÚ¥¯ž©¡·åííØÍØØÕÚÛÚÖÕÙÙ×××Þùöòé×ÛÜÚÛàŒÞãÙ«ÕÞÛƜߋŠ²²Šsjº²ÔÑÑöúÿÿÖ·¹ÏÇÄ˶¿°ÊµŒÉÀÐÅÈ¿Ä¿¶Ç¶ªŠ“ÓØØÁ˜Ÿ¬²À¯¡ÃÛßâï׬šŒšª© “£ riaabmZaœÚãÞqc[ACQFGICMEGACQP=C48C=7.7•”‘›ž]OQJHWléçäâYSVbO6&#*HR0&E+*4#1&2 +<@JHAX8FIO;=BHHEQbrU3H)0,Š¬¶«•wYPUKSéèéèåçÜÛÓßÔÕèêìØÎ×âçæâîùà••«»Š²âîìÔÙÝÛ×ØØØÚÓ×ØØ×ÕÞ÷íßßÖÐÖÙÚÝÛ»äãÞØØÕÑÏ̻ڋ«¯”vÇÜÚÖàõ÷ýÿõ«º¹ŸÉŸµŽºÍь޹ȺÆØÚÛƜϩÂ×ØÙÊ ­Š·¯ª®ÀÚÞáîÊž˜¥£™š ŠÌ›o]SaPXe£èæéy`XTXXRDLT\PYJEVOEKJJUJQIH¡¢€©¬fKSKWXfåäâàXONP`ZD& +%G6 +2351!4:""9@@66NFBD5<83CG]dmODCL+&+Ÿºž¯\djSJXêéçÐ×ÛÝÐÕÃÊåáæçÛÓÚåëØâðù컀«Ñ±°æïîÁ —¢ªÇÏØÍÒØØÖ×ÖÝïØÈÕÔÔ×ÙÚÚÞÏÃãßÜØÕÏÒÐÉ¿º­¶²¥}ÐÑÊÒÞöùÿþüŸÃÊœ¿ÁœÂÁÈÀÒœžªÀÃÉÖÊÄœ·ÆÂÈÖÚÛ̳³Šž¶Ž¥ÔØÝãñ¿¢—š©¥£±¿É}h_ZXXTX¥íôñˆdaTY[ZPHNXTR\gdTIWcN^S[YW¡¢£ª±^1-:@#$#2?-2<<9OA69=8Hu‡[PJTQNN* $¬Œº³fC\OIMGϪ±×ÉÐÃÒÞàãäèæàÙÓÕØÙâñùðãÓÔØÒÕâäãáÜŸ»¹ÒÌÑÖâéééëëæßÃàäÞÜÖÉÔÜãåÓìêìçæäâÝÐŒ¯š®ªš°ÉÓáÓÑóøÿÿøÑ×ÚÕÔÑÑÏÌÌÖÎÊ¿ŒÀÈÎÐËÍÈÊ×ÖÌÙÜÝÕ¯ŒŸ¹ªÌºÍÚßäðË€·±°¬Ä»ÃÉ̶”ˆ‚‚‚‘Âòö÷±ž–‰Ž‹‘ +|}wwv}ws]dhkonsowt€›€«°€bahoi{êãÛ·PWkaZ__ZP_ZC@-5I=F@MA<:?KNKEMJaMKRZ{“zXJNOYX]jN;F¶ŸŒ³vOTSYTSƒˆ¿àãàçååßâàæåâßÕÏÕ×Ý×ðùõìåáÜÜÞßâããããäçëïòó÷øüûúúáÄÖëïæÛŸÆßêïðóóö÷ööõóëÛž¥£¢£§ŒÜìòÝœôõÿü÷ôîìëëëëëìëëèåßÛÖÏÉßÀËÖÙßáãáãàßÜÙØÛÜÔÐÚáåòëåçäåèëééëíìêêëëìíîîïññòóéäãïñêëïíìéäÞÙÎËÑÚãëîòóñ¬˜¥­­ÛëìîìëçãäÚÌXÒàìæÞÂÞ®zyiw†\‰À—¥º²¯Àº²ƒŒ±‹bnGŽ “³²±®°±³··±«¶¹ž¶¶’ˆ±°°~¶àáåååêêèãßåå×ÝÓÍÕÙÞàðûôíäÝÛÝÝÞáâãââäéìïóöøøûûùôÙÑâíóâÄÆßëðòóô÷÷÷ö÷øóêÚº¥€£¥Š»ÝíóÝÀòöþþöñïëíëëìëììëéåáÜÕÍÄŒ¹ÄÐÚÞäåçåãâÝÚÕÒÑÐŒÆÝãéööôõõõõöôóòðïëëêéêèçååççèëëèâÞäíèëìëêåàÙÎÄžª«¬­®³Ž§¡Š­¯Ž¿¿ÃÃÂÂÁÄ¿£\ÉÁÈ»¶¯¯°¯Ÿ¶¶†„NSd]is}‚{†\lm^pUVšœ©’µµ²°³³¶¯®šž»Žºžµµo˜²œ™ŒŸÙèåáåääãâãáæçáæãàââåãñúóæåßÜÜÝÞÞààßßãæéíñó÷÷÷øöéÎàäéïÑÅÝêòóóõ÷÷÷÷÷ø÷òëݹ¥¥€€§ŒÜìòÜÀïöÿþöóïìíîîîîììëèäßÙÓËÄ»ÁÎÙßãçççåããÝ×ÓÏÌËŒÊãåêøøöôööóòóóðîíìêêêêèçèëéëìëëìîìâäéçíéèâÜÖËŒ¬€€££¢¢¢¢€®°›«ªŠŠŠŠ§‘—’T£¢Šœ §Ššªª§O›£‰€tŽql”–§·­gƒ¥²”¶·³³¶Žš Ž¹ººŸ»¹žµŠlˆ‹”š¬ÓèåäçåçêêéçãæåÌÖÛæéêéëñøîâåãåãããããâããáãåäââæãâÜÙÖÑæàÔÒÊÍÐÌÌØØÌÄǵÖàᷗ„„œ²“˜µÅØÜÕîõÿüîíèëìíïïîíîëèäÞÙÐÇ¿ÀÌ×ÞãçëéççãßÚÓÎÊÊÌŒÀÛàäøùôôõôóóñðììëçèçèçççêêëìììíïïïíìÞàÝèäáÙÏŵ§ŠŠŠŠ£¢¢ €«¯€ªŠ§€£¥¥Ÿ”P–ŸŠ“£œ šŠ”§§¥šSƒ€©ŸŽ¥’‘‡»º»·¶±T—¥‹­¯¥š€€šº»žº»Ÿ¿¯¶Žšm£·µ¶Ž¶çéìèçäèêéìçèéåèåáÚßÜÚêîôìäåâãããããââäâáãããâääãåäàÞããÌÁÑÚÓÍÉÒÜÜÏÏÐÇĉÓÍȔoYj£ÂVY—¯šÂÌîôûòÃËÅ¿ŒÀ«žÅŶŸÂÂÂœÃĺŒ¿ÈÔÔÖÚÚßáßÙÔËÉÄÈÏ»ÏæäëùùöóóóòðïîëêéççççççèëëëëíîëéëìììíëÛÑÐÚÖËŒ­šŠŠŠŠ€¢£ œŠª®£ª€Š£Š¥£Š‰?ªš¡™£§ž‹”Š™žŒA=JAD3;<1<.+/,)0GLE193*+72<543389=cd]TJBH>EDWçãÞÝàâÜßâÜÜÞàåæåæéêéåíñðéæääååãääßÝåäãäääãããåãâáââÓ¹ÔãããáØÝÝÝÏÇÔÒӉŒÅÃÀŸ­•šÅ®^{¹Œ‚Çíôúùɟ¬Š®Š°À³Ÿ²Ã¬²ŽËžµž§À·Å¬ÀÜåäÖž·¹žµ²ÑëëîùØÆÉÌÀÏÈÇÈÄÇÂËʹÇÊÎäéêäÜÞãèêìííëëçÞÒœº»¶©©©©©šŠ€¢¡ŽŠªª¢Š¡£ŠŠ¥¢€F©š—~—›¢§‡–ª©›’>?B:63<60,5722>8;K0):112515=1%&'#‘ˆai9+/:?6BÚ×ÌÈÒÍÍÑÚÚàçæäãàâåçéæèéíèçæææååâãßÕÙ×ââããââæççâäãàºÍçéßÞáßáÜßßÙÙÕÔÖ³­œ³«³‘€ÇǍ¯Š{{ºìôõûُª«€žŸ³² š˜¯ªµ¥±¬”µ£€¥ ³ÕçäàŸÄ¬’ˆŒ™ÍëìíøÄ£©¯•‹«“„”˜­µ–€‹±ÜðóÍrfmonmin`ejimZ\Pclfbcntx|ŽŸ‘€£š‰‰Š‰—–¢§Š“A–˜” +ŒŸŠª„›Ÿ„¡”BM5,.;8789177?49;398.5:?/@''-*1 +2§l‘r925"=?8àãåäâÛ×ÓÖÍÇÑÖÙÜÞâãäæèçåçäëéééêééæèçããáßàâââßäåàØÞÚÊáïïßßÛÛÚÚÙÕÎÌÈËÐÏÂËÆÆÀ»ÁÉÌ¿Š¿·ª“ºìòöüØxˆ¬Ÿ³°­œ¡ªœœ‘µ»ŽšŠ€‡¡˜m­ÔçäÚŠ¹Áµž˜Ëëîï÷ɝŠ”tto›ˆ–±ÐÔÆàå²ÇÞñó딑’­yt]bNKNNPN?9:BJRMMS^hk¡€£_^_T^W_ÝáÛ¶>QJcGW[SPNYTFNHIL+)7*?.8G?228AC9155+;.20$ +*+:.+-3‹Š£z7-7.959ÖÞééëìíëìêëäßáßÝáäåçèäÝáÜëéäçæåæåååäããäááãßßßÝØÃÞÜÞéôîÕØ×ÔÑÔÐÃŒÀÀÄÀ¹Œº¹»œÁÄÌÐÎÒÓäæÕ÷ëóûúèÄËÏÚØÖÕÇÄ¿»Ž°³ŸÂÆÕÁ§Ã«±›yÑåäݟ®Â«’Œ‚Ííîî÷ɱŽstry‘¡§¯æõ÷ööôðäïííñôòòñøö“rRME>RMIGDDIHSVMEGX¡€¢Ÿ¢fT_hVUWÙ×̱AVD`ggR=IG?;;<@D;'$4/"B44('8B/;:<10;/.49)%;B8IZ”“A88;?;.ÉÙØÕÏÒÚÙÞÞÞÆâßáÑ©œÔáæÞÛØŸ»ÀŒŒÉÊÑÔÙÞààãæåäåèççåääÝ×çíô錹ÃÌÍÐɺºÄÆÉÏÐÐÏÎÎÏÓÕ×ØÛÜÕãêÔÖëóüôñóìôôóôòñãæÞÊÕÓÓÓÒ×àááâá×ÓÐÒØÜàÙ×ãØÙÓÉêïðïöÖŒš§¬¶ž²È·¿ÞîïòôöôàòðòññòôôûúŠ’‰bQVVUQCGE?EQBOdR—¢¢žœ_BZYNVhÖËűAVLJrPYN=D@DDDB:-&),*%$?93,AD27:+'/33341<@18H8=(Mž£{=FA@=2&ªœÌÑÒÒÉÇÕ×Æ¿ÎËÉÃŒ°¯šÂÊÌÔ»³­±²¿ÇÌÔÚâäàÞáäãÚÑœÂØÛÔÀÎíïñòãããäàÛÛËÂПŸÀÃÄÂÅÉÄÂÂÅÉÎÏÒáéÍÇðôûöóïîííîúüùÏÈÈÉÆÄÄÆÆÂÆÉÌÍΟÈÉÌÕÜàæéìïìãðððïðößÕÖÚÛàåÖìñòôõôõõööööõóñîííìöóÔÊÍÌŒª ™™‡ƒvr€||v}pŠ‚‹Œ{`ZYKMjËÈÇ®EfpNWUJWROL@C,:2:@.,9;6360CD:9.<%$ +*%-4,9>3;98QFž«¥{D/3'@9>¬¬Ž¬¡™˜‘’‰ƒ|”¡²ŽÄœŸÇÎÐÔ·­ª²µ¿ÈÏÙàäâàßææÚÌ¿ÉÍÜÔ¿ÎÖíïóöòñêððîïóö÷õõòñçÝÏ­Š©®±Ž·ÏàêË¿áöþùôððïíòüþúÍÌËÉÈÇÀŸ¶Žµµ»¿ÃÃÁÁ¿¿ÂÀÄÄÅÊÍÑÔêïïïöÛÏÌÊÅŸÅËÓØÚáãéíîìòòòôóðòòöóôõõòïìéáÚÔÉÁ¹ÂÅÒÙÝÝãæ姟¡™Œ£®€Šš¶¹ÌÕس\įŠy¡ ˜”j€ƒkB:7;QQE:C9A>O66,27-.,")--#!4@F:AOAU­—ro:D<%$32ƒŸ˜ž£•u{}y}k}‰ ¡²ž»ÏÑÖ¿¶±µ¥°¶ÃÜäæäââãÛÏžÄÕÛÏ»ÊàÚïí÷÷ñòïòóóôõùùù÷öñíçÚʲžŸŸœŸ ÉÛåÈŒæöþøòñïðóïó÷òÚÓÐÈÁ¿œÅÁÂŒÄÅÂœºžŽŠ­§§ª®Ž¶ŸÀÂçòïíôÕÌÏÒÔÙÚ×ÚÚÖÔÓÐÏÉÈÉÊËÏÓ×ÛÚÝÝÞÞÞßßÝÞÛÙÒÍÇÂÆŸÈÌÍÅÎÕÕ¥ ¢žµÄ°®²°©Æâ³rÜÝÝ·ÐáßÜ ÂÏÊ¥KU««­®²µ¶¢xµµŸ  ?Ž’‡†ƒ}yu{¢vxdkzqvƒœWIUU_bB›ƒ|g{‡wZi’‰ ”‘«Ÿ•¬±«ÇØ×¹ÅčnCCLNU\Z_mrgu”™™€Ôèàïñùü÷õôôòôòöûù÷÷óðêæÝη€¢ €¥¬ËÙçÌÈïöýùóòòòòñåâïîéäÓÙÛÞäéññòòðîêêæãäãâÞÛ×ØÖÏÎêñíëñÕÎÏËÎÏÎÌËÉÆÃŒ·²­ŠŸŸ’–ž¯¶¹ÀÁÆÉÈÊÍÇËÌËÊÌÍÊÊÆÄÀµŠ¢˜ŸŸ¢Ÿžž£©­°³¶³Ÿ‘vmŒÀŸŸ“ÊÉƚ®žÀšD‡­¬®­±³š†°€Šš–¥C†—ž§§Š¥šš¥§ž”k¥mv”€Š¥€ž¡’zi]pmijx‡‘Ž‘¬‡¢©™ŠËÙÉŽÈÐÎx>:=@CEIMOPQPOPOPPV\óóùí¹¥‰ž­ŽÅÐÚíøüøõñëãÕŒ£œŠÁÚæÎÆîôþúôðïóòñíéóïíåÈßâèìñóøùú÷÷ööòáòðñððíòòî¿âíëéòæåààÛÜÝÜÞÝÞÝÝÛÛÛØÓÎÅ¿Ÿ»¿œŒÁœÃÄÅÁÁœž¬š¢¢ž‡ylmjnkis›ž¢žŸŠŠŒŒ”Œ—cfš©Š˜n¡¬šš—Š’>——”–‰zsŒ‘‰ˆ”•†Cw€€ˆ‰”“‹’“‰a“hˆy §¥ €œŸˆvgOvƒeb€„€‰”{uš‰x‚ˆ“q]wÃÑàÍMDGG<569:CGJNSRRUVVWYZ€ùúûÙeXUUUSSRSQQRRSTTTRKKIHHEM°ÅϵÃíòýøìäÝßàæíîðîæØŒèîóõøûüþþþûúø÷÷÷÷÷÷õø÷ôöÄàìçáîÝÒÝÙ××Ø֚××××ÓÎʏÉÆÇËÊËÊÊÇÃŒž³®«ªª§§š£Š£¥€¥§ªª«©›˜ ¥–Œ‘“Š„~ƒ†hQ}|uuMo^cT]SZ]CE][EOSLOILQJLVGO7gc_a[XVYUaVSahhngZSOLB81I?Yl\i}xwvZu“ +cš|z{€ƒŠ}ŽÙäÞF30.--.0258>EEIMOMNRRSSXnÄÍÖ¹\URQOONLLKKJJNPQQQRSUQQS[ÈâìËÈïôÿýöñìíè⿁jTQJL|Ž¢ŽÆáãæêñüüüþûùûüøúýø÷÷ÁáíçåïáÞÛÛÙØ×ÖÕÓÕÖÒÍÈÅ®ÃÃÅÈÇÇÇÄÀŒ·²¯­ª©§§Šš§§tŽ££¢¢¡ž —š˜¢žž€™šš¥ŠŠ¡‹iQ + +„}fnoP`k[iRKLhchajqphY^e`hUX3\uklicoh`H_bZa^aX_FA978:@8:BhaahŒoxrz‘ˆ€„zt‚™‘›ÚâÝTB@W97899:=@ABBACEEEGHKLRW[][QMKLKJIFHEFGHILNPPUSQPRRVŒ£¶¢¶áøÿþúöõôôõë}TIGGHHKKPTZ\]\^ch™€­¶²¯³µŒÆšâëéæïáâÞßÝÞÜÛÙÖÖÒÌÈÅ¿³¯·œŸÁÀŒ¹¹Ž°¬ª©©ªªŠŠªªª +¥££¢€£¡o—“” ŸžšŸ[€šaHgnaaXPRLUKRE>9?SU\Zcyuufga\mj_1Z_Z^^ku`Jczyx}}|yzz€z| +wPoviZqooR†{‰™¥šžwm‡ +šŽ˜ÜâÙŠ¢¥­ŒF66689662326=FNT\YUROPPKFCCCA@B>A@BCEGHILPTSQQOOOPQUXªîùþÒ}} +˜§µÃˆTFDECDEEGGJMNONQPMMOMNNNLMLNNQÛîêäîyYjz€‹”›£­ŽºŸÆÄÁŒ¿¿ÀŒŸ¿Ÿ»º¹³±«Š¡¢Ššš€¥¢¡Ÿ™›ž¡Ÿ¢¢š™j˜ž–¢ štœŸ—Š_GNSg]\D\MNWT`eEOc`SSPPKRVbfuusq0j}wƒ‰j[X`vz{z{xx~{~vpwvgd}€ƒ^obhix~”¬£~yc“ƒy‚ŽšwoÃ¹¯«Š–;9;?;77346?MPYDceb`\]\[WURRNPJEC@>?@@>=<=@@ADGIHJKKOYk€zlWSSQQQMHGB@@?ABACBFDFFGHHGFFEEEDEEGIMSÞîéåírGB>>9914332027:@FCADSkyˆ•œ¥¬®®ª©­®ªšªªª¥€Ÿ  ›™‘š— ”“jx‹‰Š“‹ƒ{f>_hbgfB\RN`O^aCNUbmwsttu{~|}„~ƒ1s~tmUagYvlz~onnwzxtvpxmOx€wU[PhojD‡”†wž”’Ž”™Ÿ«›mS˜µŠ¹³§¥¥l:9659756BACXjLYdba`_^_\YUWVUURPOOOPMB<>BDB???>:=;=@@DFHHEEFFEEDCBA=>=@>@@AACCDDEEBCBC@AAAEEEISâîèåîqH@==<<746766853224220.-,)'''*.30.124AOZr”€£€¢¡¡œ¡¡¢œ~9;GP^kfSFMF9ADGR_MaRcMeklBQ`snswzvuoƒc{}zz1q‚bb{qWwwvqnttrtmwwmxzGƒƒ€xSbhCi~fuœ’œª˜€––£œxQ¥Œµ­ž¯¬°«L;984;99OLC\oPFY[\\[\ZZWUVUUUTQQQQRO@-,-,-///4AEH@?@DDBC@>@A=?>@CCEISâîèçñmGB??==95655465123578885555542//--,#&" + -š§Ÿž™Ÿ™¢¢€›{9?HJHMQRV_a=ƒw^\YLaJS\sroEDkodƒŠŒuwyzsqr`1^UtzvQvzz|uy{z{{|{~}Oi€}€ +Kb~la}˜‰ˆŽšœ©£“ššˆi¥µºž»œ¯¶³šB><9=;>BCDMQbMMUTUUUUVUSQSRSQQSQRQRB0/11/0,16AEK;76:=AD:52.7;C?3/%&')/2334444778879:;;<>ABDGM{žŠ³^FB?=<<7456555531359:86545243211-.0-.'',-4©§šŠ¡¢u€£€˜l8=HJJKJJIJP7LT`]kTsXOss}yBLtukx}wvwwy|y_1e|lyPy~z€„€|ƒ‡†„ +eez‚x‚}jTq~”oxŠƒrŸœ¥¢ž š“gr§©¢ŸŸž­ºž¿t@ABA??AAEHJjWPQOOMNPVRSQQQQg¯¯¯QC90)&$"(-/2BFM;1(''$$#!!"3;D>.(+'58+16'.Ž35:8+))*-100/3458<=?AEEEBA@==<74866777533469975554532312321/,(--2©©­šŠ¡‘¥¡¥’B15?IQMQOMEO6HKOOLCXDhkpw|?czur}yx~tiqu}o[W2p~zUw†‘–Ž†††~ƒ‚ + +bkiVƒŠƒ„qikH^Z{ŸCQHwt—¥®¢¢£•Žwiv»»Å¹¯œŸŒ±L?<;7779;:=d]>954232223:?DGs÷óíÒR2)(#"" + + +%ABK;)&$'?LKHGE;9C=-'1+25 + + +-0:A:$"!%*)#!$&*6?;;8742,---,,*//13444476899866744544334220,(/.-AHR]jt}¥¢“\,1;CISQTSQV9KJJMMLOCfZKMQ;`oij|€vy‡ŒbtnY\c0vuOs|‚€uy +‡Œ† +‡ˆ +„S‚wimr +†ZUW€~kNRt{|ŒŸªšœ ›‡ƒzk‹›Š²·«ˆœ¡v224-0-..17;QD42111.1.+,).1O¯œ³š}NC:7:?<93--;9E9NKHB84/,'!6:D>-$ +/;D>$# + + + ".023INJIJIFCB<83..++()%')((+000202765575555522.,1./.(,-,.:¡Š¡”`,3AJKMNQNIV=PPRPOPEEG^KIL=HEZ6COTZs‹rVfx\C4hM\xyvs€{{zvgr‚‡}i\lv†ˆ +††ƒsmmR¥ZjYS|‡~¡£Ÿ§•‡v]`‚‚“‘rrz}Œ˜V/-.-/--/4:<7111-.291++--5;@_abb\YRC@LYYTSQOMJU‚jtR1(%#$ +34?=)"&**-/1366;0=D=$$8;<=<743110.FHKOHKIQJHE9A>><;;9874214/.*,*)(&))*++/0-.+).--.)&./.7€ž¢•^ %/4>DMMHMSAOIHNMQ@>FP]OF4HBU0EBECDF@NVU_G4Q`yzoy{zwzˆˆvnpfpsM‹†‚|{u}paŠrš€yTjXep‹‚”›–†sfg{y‚‘ +k`ev’ƒw1+,,.),0622<311-.2=8+/0-0+-G^`a]YXMMV`aa\\[[Y]†‹WC@?<7?<<;/,9>=??>@?>=1;D=$&>AAD?=<<5422MTQTSPQPOMHCDACCCBAAAA?=<6<;:76432//$ +! + +!"#! ##"$'&1¥ £”o&-34:4:<??>4.'" +JHRTGJJPNSJHEBEDECDBABA@A=BCABAAA@>=& + + + –¢£“x22069IKOKLO;BAC:[H>JHP.CBC;6CA>ABBH0$17BLYKRdpwxtxtYuutw{~isy‚¡žk¯æçæ³<&!!NSRTTRPOPMJLMFEDDIEDCCABCDBBACBDBAA3‡Ÿ¡’yC;699;DGNGP?GLG>=E<>BGEAT>K=P)>E87IB>@>AKdgqmY„{rwl{z +€tž¢•Œˆlczˆ„Csc{sn‡“Ÿ£™ƒqrilrpsWH?EGDHJ)',))(++.23/--,-,-&')%+,)&$+27:88=HT]``]]\[YXVUQNRPPNRQQQQQOQSQQRRRRUQQOMMMI‘Ëп¬l840)1;GGHJIKIHIJGGCGKLGGMCEECCDEDEDCDDBC7 + ¢z$+6:9>;BB=IIDLORID>5==>?K?MKP1?54;B??@BA?C3720g_@B^ -;Q@AB5GRYpx€‡‚€‰ +¯sw™‚~Œ~Ul\~skssr‹™“zŽ†‰|ned^`][bgU((,,)-36100.'(+)$"&%(((('&)'(#  +"$+07?ELQTTSOPNMLQOQPQOMORRQSRRUTSRPPQRPQWWVROLHC64@?DCDDEFC>569:=@FLOJKDFCBCDEEDEDEEA>JNcYMPPRTSRRRTUUTTQQQQRTUTUSQPNLEBOQSQSRQMKA +"26@HR>9" + + +$22‡€¥|6 +  + :9BEJ?IK?FCDII:<,5;:9#(146M;626OFJ:DDBB@BDHCKJ@?£–®£†•†Š•‡Lbgsrpdk€†ˆs[f~†ˆ|yzwnt‚ +‡7-,,)+23/.5))&()&&'')&*))'&# +! + + +##'&%#%.,-4<@JOU]\[XWWTSTQQQTUTUTPQQNJHQQRQSUUTRzk‰u{vgG6+#1BB+$*/B:"!E;1,52A"1-21+2$*-2:,‡€€x6 + + + +0#'5)1D=KGHFA@B8HG:L>=;8<=70>=99(&'/*KPZNIA<8@GDAB>CDGLD>?<”ž§¡ž„„†˜uo”}`‚^s†vbji}‡‰‡‡~dZgu{ +p,()/--'/.),++&'(),'')(#%" + + + + + + + + +$)($%$# + +4 * +(@N^tPhkda\XUWUUTQRPNLNSSSQTUUSyšŸ•¥µš«º¶’ti‹—rK1&B=%:Q;.93>>$?1( +!%(.1(47‡€€‘|7 + + + +0&( + + +<9*2?CE6>G8XA89=59976<:=**$)08@21)J118?KDA@BFBHD;CAB +Œ£ +|q|ƒ +lwwˆ|ˆzˆˆŸ +vj]iy•ˆ‘†~rflq‚sv}?--*01/,.)&&'$')+)& $ $)' # + +" + +" +""# + '-&$2=†WZsœ»°™|T`bXXRLPIJQUUSSUUe¬·³’ˆ–‚„²º™Ž{~ŒŽ¡^ƒŸzV]>Q>;;.3M62C-.!.;?43$#†¥£‘~: + + +0"84& +"77">.+0;AHG9545>B5..<8?'$*.2-4$C594>=9>4@@9HD?"AE63?86!*926H/!'5DI..J5*58=CIG;6:9046>EDxd^}z~bXshuz”œ‡†„“‡hdt•†gpˆ‘‹—™Š­Žœ‹\6-.412-1+)1.('(/'( #%  + + + + + + + + "# + +!.0J?HTt³kcX_WPC0U@;XZVŠ€˜~nxnZujž§§‡ª¯¥€Šªžš§œ¢¯¢§Ž„KM[XROZ1;5T;;80-'&-086 +$"†ŠŠŽbM& + +4-(301//J=14%./,=3.$9: +@ +"*//>4+T.$.)(85Q4,.79?79C5234/17ˆ¥¥ˆC_J +( +13:CCW*$5 +H + + +*/,.(Q.+$&/4A7+27:B637KE569:62;@B€‡ +~Šƒhup„j€my†Œvoj’‘}Zdl€q¡³žœšŽžŒËº·¶®Ž265,+234))($'$"#" + + + + +   + + + + + +!!!#)(/992?KBŒ·sIwewKKTVLI\†sƒž¢_QPqžª±¬¯Ÿ› +bbbv{hso”‘Ÿlk›MSiNQC7KJbM=A8?18@@--43>IŠŠ‹]_W. + +83DSEG=@8=1=;55L25G#$$ +",0,"R3+96O(3@36B45=A5642456=?=‘sqy +wy|‡hšž–œŠrv_cpsWf[iodeŽµÆùžºÂÁŸŒŸ·Žc8:541.)$&&,.$$! + + + + + + +"&$%&### + + + + +!#" + + +$#,/).3=1G?8w¡Ž”NGnq”„n`VVv„­“‘peM†‘§€¿¥Ëp[sct|praƒŸvZl`bfKM8@;;BMTTO>3<<@;27.*6H>!)0JJD8*SA330&A<2&++6@5;qyrš‘•“{§ªXhŸ‚cXJ[RVX\Tas +œ¬¹ÁÃœÀÀŸŒÁ¿žŽ¥N<74.+&"#$#"#!! +#'&$""&'+(('2+ + + +42-$* +&/'&2,1'+/).3Aƒv~Œ˜Xbw¬l6?vqf‹~„dt§±¹ÂÐÿ‡‡®nw\gxls†Ÿš˜ksjo[]THGB>JGGDLTTMFCPKF>JFŽ¥Š’~AB5 + + + +=<.O12G4F8B5GD7MVe`chO7:L@dR=\CEW4{M1/V4F2L0,,)01/4177owzŽš€­­•˜‡•–’jwx”~fXJ,DVvŒV‡Š¯¶œŒÁŸÂÃÔØÀº³@;6/)"##$&''()+*(+.,*$++'&$),,(#'## + + + + +04-&0&(!(+!)#/*;-ANrb +UT|ŠiR7G.@FB@J;@4V`G@aVI;CHS5GYb_5y‚v|sH&iD#79/734168£ }{–šŠŠ™‚yyw|s\‰q|fc/==NZŠƒbzš«¹ÁŸÁÈÛÊÝßÈÃÂG762...-..+../-287;@0''(,*&('(()%%,&,+#  +$ + +#%"!) +1/%9;/)(4Yy’„zp¡  O==m‹† +•ÁÐœ¿Ìœ¹¹¬t|‚Œ“Ž›€ªªž™Ž +~somhXnpmf]Y^VV]cb]]gghdq˜¥§›nU: +5CJ:PB&0[D?<6:N>JPX{l_ufG6aVl^Q;5DM+@<'%$),+((&'*())(*.($&&&+& + #'4- 030*#& +$)(&2.59a}™°«qjš®q<J:PMLA+GHHN2JMrdecRCp‹˜ŠshY8;4^5=XF2FdG<==OSeWXJ[=):5(1}dXU`UNW‹–”š„d` +””™miVhIKZwm}‚“œ¯¹ÂÄÎÙÖÚãëéëðòÊtÖ³[>99865767:56.,,&$##&,(&&$!$%%" ! +%.$ !"/;.17.3+*,4/;0&+/462,6YZ37QUoUkpGP^][LobMOmX|l9LVRMCA`xV<=Q",0FBUV^U631O\†z_uogplvjŠw‰‚|‰mfq|ucšŸ¥¯³Ÿ¿ÈÙßèéååâßÞÝÝÜÚØÝáÅ[PJC@=85442/,-.&&'($$'($#%$#%$'%#!''+211(/.&<889;>::869?@;44:?DM}s_NUTNHFLJIAPo³’p‰ŒŠ‰‘‰ˆ~ +‚œ¡€­ªŠ¢•œ€šŸ™š—ž§‚‡‰•ƒwcU[XVe\UdcYN?6DLMTQ[TNRbbLtT2PgƒP4lagj‡ˆckALTl^5?PeZGBrzylU=FVS5%+) *8Zb:0BW4QQsh€’n„l`mdk–Žuykqš‡zwu’–¯·ÈÆËÑÕÅÚÜÜÜÜ××ÕÖÏÓÖÓËÌÏØÝ [PKF<553/.,+!(($$%"" +"" +$# +%$$'(**'+,)+*,0-1,:588#.-04:<:BTKUN;<=H?KJJTZVZeinxƒ”™’”‰„ +™ŠŽ·³©³Š +œžŠ|aaljgjkxt•­¢™ƒ‚—ŽlypiUVLKOAPRCJJMI]X\eQi^n\NZ4^lmO+P]C>`}U_^YaTLoGIE@Wl]U +ƒmc`P<5DNPA/7P†qZG(j?@Hy——qmnm—t^nwuhgrtp†qsfr{˜¬ËÇËÌÓÌÚÚÓÌÆÁœœÂœÂÊÈÆÈÕÝåè–WI=63-*.0(% +%%! +! +$ + +#!"%# +" +"$&$ +$&+&(-!6+'()-09ANQHSPRPYaaXI[`abaZehikpqqmfW\aZZOW_cih|”¡ž˜ƒ¢’† +xŽ‰‡‡tkc[``[imcu€~drk[X>C;?EIXOJSSUCE\hIii\i^SupmqsPVb‘‚cdssdd:tXLQeŠ Ž„‡€¹­­°ºœÓÓÌÆ¿»¹·±µŸ¿ŸŸÇÐÛãäàyOI;19<=//'! + +!$'" +"##+$& +! +&.) +!!'+! !!'6>DJMM\]^[ffkih]VhUZ_bL3W^XLINMFDLSSKE?QVQLTMLONQU`bi +Š™nTQhvrngcfwdƒU^]dPa[RIFCGNUJR\engcPMdZFqbXQVY=J_WB7*/QKRME\cn5`N=+me[L>PmMBfREb[lSbJ2G[O7`D]zp`HMlQ_HLNP|RV^D8965;C9[Uahk]2&oti[VMJ?@B?CJD8CLT^T@JLMFGGJKGPJFIGLB;FOJFYOITWpiwlVOu›•sneZPMF86LIQVRU[mjpHZ|aK^gdMPUD?0N;-5>4O4AjG6_mlCF&d^mbUp`LH5J&ZSF\XjJaufKhaqwM1?Z[VppŸšÆ‚£Ÿ– +†ƒƒˆŠ|•¢š°ŒÊ·£Æ¿ÆÔÁÃŽ¶¬ª·ÁÇÐÔ£[Zc“z=**3(2'2/0-2'""" +! +# + + + +#//.05B;MFISKV\Y5?Z_SQ[TJE=>AE>C=@HB>?@72LTOIHK87646998=>=D@<<:=QKDMTe`TX@1 +!3IM53YKK9W(d_pS8RDU0!#+*!?=/!.%//297?DE><30441QBC52-)-.%('-%%'*%%',-.22653,.,.,(.95)8:8;?;A;C=9OO?99IL^HNA;2C7[WhE=?*>;/C$' +%5OZBJVK+ +5I=:95=T, +QE{lGXRb921:itVca†•€¬¢œ—¥§¡ Ÿ«« ©³£«—¢” +Š™€§š®°¶ÀÌÌÐÌÍÎÎÕÓÔÔÚÉŒ‡X8Jb_QU<15').*'23/??.:=;"#! + " +%& +%""+(&'#&0'$.%#2*0+0/B;8479589;65H;HM@2:=:QJ/AEJB>@)59<5;r“6&0 +KC>2KD3G/'<7=*2*)F/@ULJa7X3O6X\AZ6B=.2->;C30(:8<:7%;L + "EHCK22W^IUWK^?N_cfSO_v€“™™Ÿ`Wn’Š‡Šk€¢˜‰Ž™y†˜Ÿ²œ®±»ÂÊÛèÞÊÌÕÒÖÛÜßâÜݝx?%Dr²·X),$$/' +" + + +.+1(--06/9)-,,9H=59( + !(% + + + +%$" + &$$ #!"&1'( %((0,7.,2921>?905,EB962/%,..2MOG66./FNC.=9:Y+#",/7PN:MCN]\^ZS”}~Ž’o]`kay~‡„x~t†‰yny€{s’™|vŒ‹š•xŽ ¹ ÊÇÇÖ×àåÍÖÐÏàåàÛÖÛçÓÆI)-V™±ˆ7PšˆW3.# %""$(,,8+*(&2/%(.?M7@0$,'# +"#" +$"! !" + + + +(7##&"",)'",,6,*.61:7582B@85!+$8-.$D.+:5:?2r•‰B.;MHJP &1:C5%#-#FO7.D,%N$&"'&" + +!"" &!())! + + + +(# + + & *$ $-'($**%/1215/A>2* + +38&6B8BEIS?i{uX:53?ESLRY6(&@?%3F=B27-CJHV;]OMJIIB;/KagaEBFGFPb6477?6:3(887X\363#8E;SXl\A599H# +AB85J +B +%EMJBA-85!@PzeisdZPYgzjoy]un‰kgd`ibb|x„rSrly€|{pwˆŠŒ Ž·¡·ØÃÕÃÊÎÔÝÖ×Âɹ¹¡¡«°ŽvZ=56@Gdª·ž igozŒž§¯žÈʓa35<80M>-"#%#&# !#!!$# ! %%$#!"(!&"!#%$ +#+"$" + +(2! +!!)! %%#""*2)$-,59BDLKLHXPVSLA10@dA[$#1-++ERID!6 <->C\U)?3%/kGu~se^VUXgec_h}|hsqX\kV]\ZYeu}tsquhv{y‡ +}‚ŠŒ™°žÆÓÿÅÊÊÃØ͹µ¬Šš—”† +oP3..=MŽ°ÂŒž±±£š“ +}~~‰Ÿ±¹œ·²d605,#93*('%"$'&""$"" + +!$ +",&&" +**()&"4  + + +! +"" + +! +#% + +#! +&5>TI87:FH4B]M]D722E:E<\e=B@2CN?- + +$XKBNeL__6P`i[zp`eUROEo`\_c}o]r| +„qgukXlf\i\ot~‚‹nz„s„‡‰©·ÃÏÕŸ€¥³²ª³»š¢¡Žš’•—›wZ>78?i”š£š  Š£¥¬¥˜™›Ÿ–Š•¬»«ª—’WHg„€7222-*.4)##"# + %$& $&%0')(("$!/ +# + +!@cƒƒ‰vL73).ERXdfII:=D^L<@<[bg@P^[ZSL0 !,?HPD>E638=AVn“·ÍØÏÀË¿®«¯“l]cjxš™š›œ¢«²ºµ³·®§œŽm`MB1.(,*',&5 +&&-(%%!$(+" +!$9Ja{’•–Œ‰ˆ +„‡ +}nC*&QWTkWZpY^oNNcm_PdK__8Pa\RkIE7:^,bJSozzAFdJJgM=GFL>86J@C1G:9- + 8?R:gI%HJ*JšE\ah`_XtUYhpyyy~„rq€wbllf_jxus„}|ruxrrfikwŠ•–—ƒxtpxjz‰•—¥¢–“”•†zxx~•š  ˆg<58AGS˜³ÄÌÎȹ™‚Ÿ¯¶žžŸz©—’Œ——¡ ŸŠ¥€š„r}hbUL12)%7)*%1" + +" +;=HVKTbnzny†ƒŠŽz~„‚vkjdKD:;Hl]JfnYQOUP]NaTcMOlG`cgsh +XBca6G9MO]T'0QO60>5IBRDC[O[CX:F=4 +,CMOmcTmF[LJFŠD9%c``HINJCD[qx||}ƒ€„bbb[cvu‚ +rrfifQXhgc`_gn{{}wv\`[bplsˆŽ‡Ž™•”—›¡€¥ –„^<;89MGI>YSrTRQLJRO^GN71[iZOE)PbWPO;'CNOW;KHRI^Za;GlFBTmTbJY_JjDS&[4H9<7I]DV627TGU_dYGTECD\xgS59Die_I@UeP6R<-%BEEJdIQfpefU",Dfvj‹w†}kjVHREg]T37K]cYY\wdYXQZdpqrx~ytq•“™˜Š„ +Ž•ˆoaNHPNIZip™§–˜ššŽujgmnt{’˜šœ›£––™Š~{oTHA37+00lpe^|1+q|`KYiwdkI2Uq>'.BAQ`€TAHy|sqjP- ++&AXDSlL +,897@EGN[YLpflvƒŠ~xvvdnvwxklƒˆsfG=@KFRZdp|‹Œš¬žŠujiluz“œ™ˆnm{„‡}w^PYYZTUTY\[`feegd`]Yacd`_aejvnkdcOXTNJTdv +€‚ +ˆ‹””–u„Š +yUMRYga{†l,YOkpŠsh>bEoh5USh\wxT\LAKKeSSB@RYK$DtkA=.K=EXFNNixF`ibVfWpiogbV-lh-g3*XUES68/6ZBI3,BFP1$<7>`r]F]i\["1ID7%"khW.)&%* +,9CIT]_Znolqqq`YW[W[X[mx{mdixf_]bdu˜žš«²ž¬Šž‘ƒxqs‚Œ˜š Ÿ”ŠqimyxtkjgdeicZZWbb^[PWkOOH=?WPKDU2LVC^HH_V*>M>I093-G+$EH: +$Ei?kLVŠvp]ieqoTtvJ:3]QI8C.?5F^R;8/%DRUABNdtpDe^ecTKhaoƒymDDE"(9.3*%+ + +.KGSbojWW@M3?FCNsfUanmbJ;3nLE@hh:0T<,#8BaS0Z^N(`lVzT@>>]|zX?/4. +1\WL6P@WGMˆa^x{’P=hGYjdO„MBK?Ykƒ‡•Ž•ˆW_6.OL];#<)4XY*:ZW\hmyyk`_c^XYWRTTVRU^WQQMLJLLKIMLOPSU]Y[j_oaZQKRD?B@FEDHNKQe|„‡™ £¢›’‰{umkjpjfhi_TSPW[\^[^\ZV[]`_ei\NCEUVXw„vnelqqnrqp|~jcjlm€‡~{fXZlytT:@WEE:t[}w\]W[VD.GZ1JLtA,`TF77E[p|iTL5&IaShOCJ^p]sl_H1214:;1OkP0) +2Ml ;HPTp^hqv€ˆ†ˆ{vljjd``\]WXTVOLJJFCADBJWRY\YaZXY_ZXUUJJGB>5@DCHEDGDKZk|†ŒŒˆ{roj_^\Zedbdmmgfjnwsllmkgfdd^WSLA::@CLJ:Y[stb\\r|yo{ƒ‰Šˆ{opq_dt~}x}zxgYPPO2CbZNdkDAWh[VRoSV!0IE6@JLDQ6\iYXX\C*.+LO12\[ +?nyhUITNrUPS\ebRM=A@4TS(,W\iT]`MIRUQltdLNZSHQiuyy}V.., "g>-NPZOHMbnty{y€~oiga^_[WUSSNLIIJFLXS^ZXNZQSRWKGRPCBCCGIJGICEGIEEKMP\iottnkjjcZXZZ[[WWV[``][ZWTZ_gkhjjggb[]Z]Y[WSYNHTRblgd]rwgS`u +kaUYqrvqj +{zwql2203),,/?=PT@bjQABDZ=GC8=>KF:[JB_RFM[W/"Nm6.CdF=_RAFULA[Jq-;]H2MOZa:R +U-X@GHIM?J_eLcjVZdocZm\egiaXSSINJHEcT`ogW[aZdjhmqnmljhigh^YY[\[ZUSX]_[`wj\u`QQYVOBMDA@AEDHDFGPNSNHDFGBDFIKKSZcc`ac_WX^gicZSS^ebZWWXRT^\TPLJV\]^bjfaaeb`_LbgmcpocYsi\Ydqtn`Zbqhz‰–~{Œn^SFC30 +<.#&POR\bLK<_YV\UBCDQJ-ZR3"LF>`J-CagcTF=,:[a*3Ohc58I) HA#B:5cMWq7<-F.K]DDLIN15>d`hhcd`lu|rknka`jrvu‚€yxjfqpnolsonnjsnp|ƒ‹ƒpqwxpfqvuvtqwvrvqdTFEFEIKHACACEDBBOYQOIJLHJOPROIQUaife`XSRUVafb_a\RRVTLKGIIIIFCDJNPSNTUOWWXdijYl[s]Zgl^eTVWTap~‰†zn\bemoj€{`PPIZ=029@_[?H>2ZHJ^gpCE=C4Z:!8F@Z@2\UlU4WQ:?,Qb+9A?dRQNSLBM46YMZTSYF/=>BFWfD

)*3 <7^2$.BAA\WCfYfE47RH7N5%HC8"AtiZ454ED&-LICVQM?D[O_H6;'5OZgFKQQMWbWR/99K1 +-(u‹„‡xtƒŠ‹ŠŠ††š£’˜™—“‹•“Œ‰Š„ +‚y|uw{{w|}ƒ†ˆ€‡‰‰Š„„‰„xjcu‰„mmdSOQQS^aZbiebZ_\Y]YTWWSNRPPPRXhuxupkpldYQLNNTc\SYZ\[djZTW\XWZV\a_a_YQG?>@ES[OT]RYT\lw~|psaY^nnlj{thT^\wmjY:**%2,148PP<##O8F-!!K_H4G@N>Z5WPQGiS,2IJ3P&(/]CEVMOKI2K,$ +20@_&DIQVUQD65-9M3ejww€ƒ††ŒŠ‘•š¥ª«­®¯šª¢ š•‡~‚Šˆ†ƒ‡‹ŒŽŒ„„‚pƒ‡‹Œ‘‘˜˜‘x€{c^decc`egfZ\YW\Y[^VOKPVYTW]ZWQTPRQPVis}ytxog[UZXUWge]`hjknqjdei^XibPIABHTXVQMUVNgHIKOYNMamvsm^QY_ahntldQAZ[hWI3TEJA% +HRI@B +3fY>60+:4@aPB]_=SX8Gwn_A=Wi`Ybw&ImHET?R>VVy~mW*/3F\Q8Y;3E*Ap<[SIOc +KGHA +FB9 + -+Imhei +N8xD,4,1Y^Y_8)ED;C.93MH7# +"'9E10(TC +2%2,:V+Ydv\4j:'3@B^l?;M1>/6&"71R97E:-BNFAH7u{LC.2CGSqb\jejT;SDAIA;+OEL@55:Uln%FWC;G5 1OPH8jt¢§™™œ”–š›£€£œŠ‰—ž€§§€¡¡Ž«¬Š™‘‡‚ƒ‹™•Ž ˜Š©¬ž„¢š¢™—˜–y‰“•˜”ŒŽ†‚qqtusswƒ„||zsknv{yf^cggfa]ZW^]Zbe^[YUOMR\[W^^cX]_cgpbTMOVQPRQLU[ZY[_QQRQWTRSZb`WEDNCLKTQYNWXfp}usX2"%PgL+TlWZ68IgcFG$ +45*&90=B=VC\Pe2^wP:)5[LmtpYELX]@LD]qH=S+Rf" +Q(g€sk=0EJX\Saaj\<\(UX«« € Ÿ£¢žžšš£ œŸŸ¥€§šª€²Ÿ€š£––ˆ‹Ÿ–|”œ«­£„š¥Ÿš—™–ƒ– £€ž›”’Ž‡‡„{€vhbaomddjggeYVa_[V]cifgYSSUW`eag`XVUMPQY]_^]][[`a`b`bcia][[__`[[_bdY[bbbdafnha]Jb[c\WaUPZarvwzg<9,)P9?T@BB2GDK. +9$4UH(+D=@8DK;gRfSWTmhTS(Db^PXL;N'&QUTnzoMMoihkR -piIGlCNO`\\V_bLQI.Nb·€—“Žš‰”›£©§¡¢¢™‘ ¬š¡Ÿ©ž¥‘‘”‡‹ +‰ +€ +Šššš¡‘€§”ˆ‹‹„—§§¡œ•—’‘Œ‰„yugdhonnlqulormlljbcehnonjgUU][RNQQPPTVZ[a__ahieYSPRXPPT[^^WSNSW[XX[`]WSWVMPJLSYXFUSekYfTZ``pr€oAA?503X7LIFJJYS93/A=J/,Y:B[P9]@FDdTDFb9rZdPSg\AZL#4D&K2GKw7$4V‡YU; +$blrcb?[^kk_TUDSeKU8&BVŠˆ‡{ˆ•Ÿ œœ€š¯®–›Š­©¥ š›™Žsfksjdlv€™€§š—ž¥¡ž”“†˜›ž™—“—•ŽŒŽ“‘Š}ywto{†{v{†|xjdfd][_itwujcXVLORRRUXVW]YXYZ\_dgdYW[^XTZ\UVUSQJKQUXUZUOVZQOMLRTRbZLPALCMb[_abklgF=C>4;9USITP=CSY;.&:3jNOa€sp9Dc5LO^75aw_bTjjMJ_?LA#:P5-=\K{e9 +(dnTB4Gk]aZjO4QH>0Bl«“™Œu{ƒˆ–£Ÿ¥¯²¬˜Ž²²±²¬€£œŽ~o]a`^rnrˆ’Œ–Ÿ™¢£œ™š–œ ¡€›Ÿ›“‰‡“‰–’•’Š‡„| + +{tu}€„}j^acb`Y_nxwiYQUSUYZVZ`_[Z_c_Y]bbb_dded^W]`[XTRXY[]XRKRSVX^][YXa`_[[OOPX\OE\WHNGigUIIB,?"KFTNSKapjQ=4R$aUaZKSTW6Z10EOLVkTO`olC.AB:,MF6SLNT9>xkeDDZ]^SWk_fSZ]sO,@a`JIOU>I[R+Nk€Ÿ‘‡|“™šž¥§š¡§²²¿¿Â°° žŠŠ„]`bjnhmdnuvƒ™Ž”–——–‘ŠŸŸšŠ‹}ƒŒ”‘•‘‰‡†‰ˆ‡†v|ˆŽ +|€ƒƒ†Š +vuojabh^XU[_^\dcbnrxrilfhb_VTOVXYW\]ZXT^TMIRVPHQIFQeSPKLNHMGELPLPROJUe_0F$BF:L:VMPdLTO$@[ˆ†Ž€€ ”›šš£Š³Ÿ¿ÀÁÌÄÀ¯™‘š¢– +‘‹zgXco~y“€Š‰Š”‹–¥©Ž’‡‰ˆy|wx†ˆ–‘—–˜––”{~Ž˜–”™–Ž•’‡ˆ‡‰‘Œ††‚uhgbdkomnpvpssplnkr{||uqlgbe^XV_`\ce^YR[\\RWVV]Y\X[WX[PUSV\PEO^ZKKZYVI:N=HTHGGE@Da^ZpiVM[d|NnuN]6 + +)(^O]ACgnwp^WC3’c4HX?G3AKUHJKi^>XRGM+4vP6HhlO.<& +Bf|meKaYtaR77:SQGSejb*\,BC>x‰le=RhiJM +aijK6a\LkaSS:;K86OJ`}šŠªµ·²³¶”˜™™¢žŒÃÔÙÐËÏÉ®··±ªŠ£§šž•ƒ~–”}y‚“—ˆŸ–Š†| +skm]]^o|ƒ†}~ƒŽŠŽŽ‚Œ–›Ÿ›’›£¡˜’‘‰„Š“‘†‰|pow|sqoorqqqsw“ŽmdjgWV][RY`ZY[\\ZSRWXe`^btsifhhh`gomZBEUbEDZL`FG>B:DYEA?TYHEZ2/>_J(NP + ++%W?LZeWƒyWN-& +W@4BIIM#S&6`aymqY;`OrlSBfarhs_frlqN9Z]A:?CIkrz§«µ·¿µº¶ª«°¡€žŒËÓÑËÔǺ¯ÃÞª¥«¬®šŸ‘£œ‰vž¡œ‹•˜š„ymlYTP>O`{Š~€xutw|†’ŒŠ‘Œ‹Š“›š‘‘”š–•Š‹ƒ}„ˆŒ‹€q“™‚nf~mnhehf_]ixvx‰ƒiqrupdlqcfWbimooc\VU\bfXLHPUV\lsbKEMHG@SHFKPQUT@HNLPR670DZA<.FAD:#RUX\,8D!PE`sgjdz[RFA(7AM#@;"gq^bT>>]\g]vZ[nsx`d[kM?hTriX`hdqfœ¯¶¹ž»¿µ°«ž±œËÎÐÌÔÎĵÁÇǶ§¡«©°š€¥‚“§šœŒ•‘—‚skZPBD?H]~„|yuoorp‚‹„’’Ž•‘–„ˆŒ–—œ“‰|‚‚ˆˆ–Š}mhlmfehaVZsˆ†‡‰liy‚‚vmƒ†viW]^^ffl[Xhq[/"#&(,49FB$,:::K?NNJHLXOVP‡€˜A&7-E_6+0''4~cCF +.FLMLQ+GL_BTk,hZMTO +IQt_R7GAR:GvW1@+QBpVOJIWv +RWjULH6QikpihLS]IUªŽº¹žŽ¹µ®ª±°ÈÑÌÒÖÑÙØźÉÊÇÿ·žŽ­šŠ« +“¥ª•””‹ˆ—‹qfXPGOTO]„ˆujoiimvz††}~z†‡€„††ŒŒƒ‚y–™–|zƒy–’‰†›”•ˆossvvoimn‡‘Ž‡‡‰—›”‡‚€yl\^f\TPVU_feZM7-6A<$%)'7GKQU[^ZIBGBOVYDcšª—-$4=\4)' +NL!1,'"-;-BW77ATcoDG]mM:6GZYVyVVNQ-mo[RVJ}YHgN_KNT[X9a\IIWHcWI[[+CE;U.WOÀÀÁÄÂÂÀ±§·œÎÊÇÄÇËÕγÆÆÆÄÅÁ¿¹š°¯ªœ–£¯°—‡¡¡¢Ÿ§˜‚tƒ†ihtidt +xy{}|pkogduyupocTPZzƒs]h{su‚w€†„ŠŒ–Š„|–‚sj‚yrjpuspƒ—ˆŒ†~Šˆ‹ +| +„qqhkeopuuuneTZ\_ZPUT`\^]UVVVZdxxjURWX[IXŽ¢†C'>A +?B. +$!"(687?VZ4BB1;?V;*LI7KIO;B.tkG_E/37Lao_g^\nE>KHR^PQUM3UW3V]l^XmhÁÃÍÖÙÑĵ¬ÂÌËÅÆÊÆÏÑÆÁžÇÄÃÄÇËÊ»¶¶³Šš¡¯»Ž‹¥§¥ ¥£šˆ}•“igurnrx€ +ƒƒqm]S]ptsol\RUTZb^X`okiqz~ˆ†‚ŠŒŒ‹ˆ‚}phvyvg^LZlŽ‘–Žw”ƒ|ƒŽyfp€ƒ~€~mX]\SXa_ZUOP\W[VaqrjjcT3N\ogŒ\HƒžƒGAQE/CP +& + +" + + #$- +),RG$?WWS150%R"!1,B5'RtIKI>RVAitcn€}e*8YYf?CUgG!6IVjPV]dJ`ÂÊÍÔÛÚÄ°žËÏÈÎÈÃËÑÈÄŸÂËÉÆÊÊÉÅŽ¯³«¡œ°¹¹•Š¢¡Š€€œŽ™—Žˆzqy„ +ykpt€wfOLR[dpoi[W[`a\bd`aad`is}wp€} +ŒŠ +—Œƒoy“xgRDPu„™•†p}€‡vcarzxnlrpiovxymimlgglaYYdmw‘vvbBe +„€diyh—š•xM[gRVBG!:R$$ +$""&#7R6;&(@;UdaV?8Q]B2O;S]IGMF\ZYt}tygH3SabSNTaTgS9?WSKS2?YLU\Q@UV>BDBaÏÑÏÍÖÛÚÛáãáÛÕÕÕÓÐÎȹËËÌÊ¿¬£€¥§©Š°žž²–{”’š–™¡Ÿ¥§“xxqlxƒsd\`cXYWPYY\ee]X]\d`d[PRXVhqtWWp|r|uˆ–—‡|Š‚‚fI^j|ˆŒŠ‡wkpPQV\UPPYW]Yei`msqzwoQbemwUW[_^a{lWFc}„a7@IXlr[COegC1?Q8H&;@N'/6'# &)'-OB( +B 6)5?@=9%176DvqYQ*8D.QGX0AEhXƒviU6>ZB"3=#6JJ;HWPbgXi?7TRÍÆÆËÕÚÛàßàãàÚÚØÓÐÉŽ±ÈÊʱ›ª®·ž²·¹Žžx€ +ŽŒŠ””žŸ¡¥Šž‚ˆˆ‹ +tlmmmeY^dVV`nqi_[bcbqofPSWYbwt^fw|s„‹‡p}‘ˆx‰•‹‘^brwv +‡‰†zƒˆzdUHJRYubckuomxt€w_MYibSSN?LVmfgT?8602- +$' !HE "2*!/2184B6 +2;&/1l=OOZ9R'] +CTV_m=^3HL"9 +0 +ESI>Jg^geV]RS\8¿ŸÅÍÓØÛáãâÞÝÛÝÝÙÝÙÁÑÛØÖÐÁ»ŸÄÁŸ¹¹·¶²Ÿ›uv~‹‘”¡¢£€£ŒŠ“•“yndjngeS[PZnrro]Vfkmytqhff]`leYnxuu‹ujv‚ +so—›™Žotxuvy€†‚WKK`{soxwswy +{‡fIO^uTKKBGURl[dRIV7.)BdsrSRV[Wjmfe[OMI +O>! +! + ++ @L&$1)!',/:6:5 +5A1/CSrN2Q/)fRS0&2nlk[HP=3"-  +."!2C +(8*+%+101?= ++:*$+)A@[k@}4/U55JIAP;.]`B7 +?RUBB JFHV)8D_JTZQŸœŸÁÅÊÒØÛÛÚÕÜÝßÝØÂÕÕÒÎÈÁœŸŸÂÂÄ¿œÀÃÁ¹€­ÅÆÈÅÄÄŒ§¡™§¯®€ ¡§•u|}ni}Ž€n^upwndffainnh]Vgphm‹—„„¡œˆcr‡euŸœš–‘†€}ƒ„‹gDCHBC>Go_iaYcYa\\aa_WNU; + +0- +! +H + + +%..*)(/683, +->0($(<0FMv`09VB42;63@2?EEQhW;1EIQ*-5hTW=K1IAaE7/P206&4@>5C9:89DS[YQ5BQI^cUF\XWHA1vjX¯®±¶ŒœŸÁÆÈÆ¿ÈÈÇ«¹ÁŸŒŒ²°°¶º¹Œœº»¿ŸÀ±ª¶ÈÈÊÊÉÃÄÆÆÇÉÈÅÂÁÄÄ¿ººŒœÃ» «±—¢¥˜ +}tlfhdWDJp|Ž¡—’•œ¥¡ƒs‰Ž€rŠ’“|ˆ€Ž•‚`NRFJ^zŒrR_xˆ|xwŒ•£¬®œ™Š‰xrigc\QKSTULY\[TLJkaRD%RlvqhdYYO]SbLQJ) + + + +1R69&?:EDVGTOPjD46U7 ;@Z88R®ª®°±Ž±³µ¶³¯º»Œ±©ºº¹Ž®ª¬®µ¹ÀÀÀœ¿¿¿¿Ÿª«µÄÇÃÃÄÅÄÇÆÄÆÅÿÃÄÄÂÂÂÂÁÃÆIJÃÊÈÊÀ€|kji{‹ysgZeuŽšž«®§ ž„„˜‡|—œ™¥Š“—‰gOTXU_l€†eHa€ƒ}ƒqƒ’˜¬µ³€Ÿ›ŠumXjUANJGW‚”‹]\iai^Ro`hdQrshaXRWVXK^D# + +K? +D (1 +!!&'+2A"&"C*UAm! +$Y?"*EJG368=O9L8-&B. ++BGG@19?02>(7J_B"bZ3@\FAIŒŒŠ–šœŸš•¢¡˜—˜©€ª­³Žµ³³Ž²¯±°®¯ª™ž®¶¶·¶Ž²Ž¶žž¿Á¿ÁÂÄÿ¿¿ÀÃÄñÊËõ­©©¹ÀÁÀÁŸÁÁœ±zo£ÃÉÉÇÉŒ±ÅÃŽŠ««­¡˜‹€ƒ”ž›lXPkƒŠ™’€t[Ui‚{†‘‘ª­±²¯€‘›Œi]OXBRPR]UZSQSK76. 0 +56GPRNUZWQIIQ;_-%0'‹†‚‰‹‘‹“”„˜‘˜¥­¥¬°³±³°¯¬««©®Ž¹Ž¡ž±Ž³²±°Ž¶žº¹ÀÂÂÂÂÂÂÂÂÂÂÁÃÄ·©Ç¯|{ŽŸ±¹ž¹ºŒŸÀ»®€³ÅÈÇÆŵ¯ÆƳ²·¶µ¯§Š¡•”ž– +d[Wt|nx\Yi„}|Š–ŒŠ¯°¬Š›|\feUMJNQeqjS>UnUUL\YXRTH,JL>WUF=B==9W"!*3FEMG - +. + +'*( +, +"3<_W7j$5C'$M+4:8A8?K4"1?A%:]H5@N@HHƒ~ƒ„Š†ˆ“’‘’’—˜Ÿš«¬­®ª«®ª­¯­«¬°®®¬”¢²³²²³¶·¶¶¹ŸÁÀÂÁÀœ¿ÀŸœºœŒžª ¿ŽHOjª²Žžºœ¿ÂÀÀŒ¶žœ¿Ÿ¿œŠ®ÃįŒÂ¿Ÿœ»¹¹®š œ”yqdlƒ‹ˆ|kƒpv€„{‚‘™—›¯®š¢’‚q\eOd[MYŠcMPJViTQbmbum^T3@KLT<.7 +!"Y%25?;-KB2)  + + +5'")&N,;(&-9/c'S@n;)#?8$*/9>- +EE,%"2H/3?49?W=%/JG<7RFXP”Œ‘•–“Ž’”Œ„Œ|ž¢š¬­²²¯®°Ž±±±ªª©©¬³°†«žµµ·µµ·¹žŸ¿Ÿºº»¹¹ŒŸœ»žž±®ª§ºŠlFDNZo–¯µžº¹ŒœºººœŸŸœœœº ¬ÀºšŸÁÁœžµŽŽŽ­€¡š’Œ“ƒqŽŒ†r|nu +‚~„‘šŠŸ«©€˜ŠŽybK.C^g]U<%3@uq[npVm‡Štg`[MH9PB/+;=74_;>HJ.5L;C +3($@"e6K>`.> +6-0CF% +6F&/(747<;):T. +FJHINPEEA{ˆŠ‡Ž“—–’‘–¡¥©®±³²°±²Ž³µ²°²Ž²­®Žž~®·¶¶µ¶žºœÀÂÁŸººž¹·µµ·µµ±­­€¢­ŠVG<>EIš¶ž¶µŽ²µ·º¹ŒŒŒ¿œ¶¡Ž»©¡»Œœº³±³±€ –—˜‘Š +”Œ +ˆŠŒŒ†Ž’‡ˆ”¡¬® €¡‡ˆ†iXS?\YtpsL8:Epoc‚|W‰‹ŠrcRVDP4/(@EL?O]GC24&90)$TR*%$BS;+$"34/"F^A+ +MWQ%B/."BG&6+%8L-/!(786*/[2-F<6) +; +.’•‹Šž£§š€Š Œ + Ÿ ¥¬®¯µ¹ž«§©¬«¬°žŒºžŒ¹‘µžº»»œÁÇÇÆÇÅÂÁŒ¹¶µµºµ¶²««®žŸdE=6:EM|Š°³µ·ž¶µ¶µ·¶¶¶··®—®¹’˜²±Ž·¶¶°©¡™‹‡‰‹ŽŒ•œ“˜–‘“Š€Š§£¡©±®£™˜ŠŒƒs_^XVThY> +6<7+1V^XP=Y^/4$$13 +$ +;&*@aM77(IKCRUc^KD:G:,SC#3U\‰~ryzdg86 +2: +1&N6D3 +Uh+,'5K4 + +&9J5 +3$38ZXBC!&=B' /‡ŠŒ’˜›¡šªšŠƒ™·Œº³°°°°µ¿œ¹ž³¶µ·»ŸŸŸÁ«šºžººŸÁÄŸžŽžµ°®­«š¥§§ž¡§¬ªˆˆb%'2BG;@e]M2#,EA\NR,3H?@SXQaNFLGQA0PyŒŠ]VlaTXMv#'*SW'2*ARpVWsŒ‹–Ÿ¢™€©ª“¡§¶¶ŒÀºžŸÁÂÀÂÀŸŒ»œœŸœº¶ŒŸ µŒ»µ³¯²ºž³¯¯ª«¯°¯§Ÿš™šœžz—z?1OˆŒ™¢œš›šž œœœœœž  œwŽ†‡–Ž‰„Œ™ˆ‚‹ˆ{‡zluœ¥Š§¬¬¯Ž²¯¹º¹Ž±®©ª¢™ £–†odaSYLDFFCG\ok`J+)-I;;3#CT`.%-?>EVShBIKGF#f‡‘”•ˆvNfdLPg /+k\:#@RC$29JD`T::  +> +*5E&-E*7bE $1$FE9=a>^=[HF;C”‘‘Ÿ€ž££™“š¶¿ÄÅÃÂÃÿÁÁÀŸ¹º¹¹žžŽ»º˜ª²²žŒœºµ±®±²°¯®«©š¡œž–”ž|†m<.Qyup†‰‡‹ŠŽŒ”•—’–“zw~w€xŒ‰ˆŽŠ‰Žyy{v{{rxc~€ª¬®°¯¬±žŒ»µ±¬¡¡šŽzŠ“‡~o_\WW?DEIUZ\L?HZcPIKB;@cDADG@NTJCSGLDI8 +ADIOgrw†ƒ‹ +TUƒŒ‰3. +zK+!-lU,9NLFN3'G64 +@16GD=]YB[‡‹•šœ¡Š§‘ª°£³ÁÅÄÃÆÆÁ¿¿¿Ÿ¿Œœº¶Ž·žž€sv®·»º»¶µžŽª©Š¢¢¡œ¡££€¡—‹‰o`-+Zwqm‡†‡ˆŒŽŒŒˆ†‡Œ‹‹‰s{tu~tˆ‘‹ +€ŒŠ‰†Œ††th™œ©¬«§­³³¶·¹Ž³°Š£’‰€zˆˆmedb\]YU_XK>OGDJD;QV>FZQM2,[LVVM6HPVZ]L7LA!P418?IK=M`fokZ@q„!1=uw +4&)G@<8GJW>0/@L=3K1V2>2FH09DV]`\LH;05TJ<:DPK3^UG"& +5I73:F>&O=2BVWQ0 +(QDTICF`<27@IY4=P?A7<,OH\kU=SfL9JTebE\H8XP8™—•›™©¥®¶º³±Àœžžž·ž¹ºœœœŸÀÀº²¡«©«Š¯Ž±­®««ªŠ§ £Ÿ ›œ——œ‘Ž‹‰„dpc_sˆzly‚ + +‚„€€€€‚€}vsdyas€r†‹„‡‹„„ +~qv~ƒzgcto~‘¡€§«ª­µž¶°¬­­µ¶¶±€ˆŠ‘sj^VV[WZULU\^X\ZRUSUIUN1!EL9JBACA;C^1?MFL!*<>A% +/F59G@,">FAC:;2%&8?M9KHcC'33?P&MD<1:R[aZD:@HCT)CFT[ZbKd`gR@X_Zg[?N’’‘•“«Šˆž¶¹Ÿ·²À·Žµ¶³²µœ¿»ºŒÀÀ·±žŽ¹ž”‘®¯¬±³²±«ª«š¢ŸŸŸŸž—”““’‰†`mrv|ropm{}„ +‚}}{{~{~x|jdt_vyo~“”‰‘Žƒ˜~vlgvˆŠ£¬¬ª¬¬¬ª«²®«ª§€«¯­Š˜ƒz~oufZSSNSTV]`_\TVMEZNNIO2OF97EQN1EU9C,%7,882@.+(:;'(?FD! +6N7J;8?E:=<=MJgFB:&-,U.RG:1HWB0DZf^qYAN6RodV\b_XEDKWeC?V‘“šžŠ®«Š«µ¹Ž¶­ž³¶±®­°µ¹µžž·²«±²°¹Œ·‘®¯«­®§¬šŠ¥¡œ›œšš˜˜–“’“ +|\x{~wbWVdx|‚„~zusz€}~zxwcala€‰wu‰Š +|qxroz|{‚„”–”}žŠªšŠš©§šª€§ª¬«¬¯ª¡¡˜l_m]XSURRSNMOPRUVNSgRSGH0BJ53TJVPY\C +:-=24I\D6B@(!?. + * --O@@EMOVONJ]YžœŸ”ŽŽ ¯²°«š ®­²²³²µ¯¡¯·º®§°©«¶žŽŽ’—¬š©©€¡§©š¢€ Ÿž—••“••’“Œ„xsi„ƒwc[Y^klox{{~}†€u}wupU[gs€zm`tsplnthov|qe}ˆ +u‡ˆš€š£ £š­©Š®«­¬­šŠ¡žtn`ZY[XSTKNNNJJIKFBO_UNLL5 +>GaSMWUR[KK0&MC@7..6@8*/>YNI7.0(3A;I31%*'+BQXX^:53BF?0:OED?P__\QX[T>DPD39IFMQSCUdwV889BU•’†gK€¥ª¬¯¯“ŸŠ¬«®­£³ºŽ¥«°§µ·ŸŒ°®•ž­¯±©Š¥£¢š¥€£Ÿš˜”Ž—’’‰teiƒ‚~rec_Veiov‚|~u{wxzryzwpY`hmi\aTu€ +nsmpsq{iy‚xtqqƒ[|“–’’”¥Šš£¥ š‘”š«ª¡”ˆY]_]\UOJLPOJFBIJGZVPOXSCQF_fcA7PNGSND0.8-.9\N`kbWTJ>:+043D+!13(2MJ^;I1?6,]MGR[jdI[WEnvjBAJIGSiOGTHRH]odDR;DRR†vnybO +˜š«­Ž±š€¥­ªª¢Ž °¬œšš£®°ŽµŒ±œ£¯°¬ŠŠ©«¥ €Š¡ž›œ˜–Œ••“’Œ€gbu{zkhg`hsp{wxwwzr|ulx|wXg\coprNgryppgvjxk`u|€ +y|‰Qj‰‹‘ˆ}s +Œ{viesu„“–‘’^\_qi\QOROQSID=NPhMK_XEJgWbYWM09JQUKHSH8& +,/<'D;EHdaZPl„xxob,(9C--/7J6+/K^KD64Q;OGKRVED]lmak|cW7QSOR`uG]PHBQipOSHCE;M~ya{uiž€š¬²­°¥¬­Ššš¥££§š€¯¬ª§ª²¬Ÿ¡Š¢Ÿ¡Ÿœ›£™šš˜“‰—–‘Ž‰om€yvpkgmuxru‚€xxnwrslR``x~|zYhuvmkknmoinvzsrdq„Sb}ƒƒy~siqkml^_]geel„–jj`hYZWOVSPIA;35RjLM_XML]PVXL?85GQXKTXI659=GMA>PDJ9LZPSQeotru/&QuC'8EPI@PbH[WQ9%4=D=ZZvtkelmhnQ9ibmyjLI]HOM]€\ZKGJRSSmxuy†’˜–§°±¶š§«š’—š›€œ—¡€©ª©¢¡ŸŠ©Œ‘˜˜——˜•˜––š—˜–”“ƒŽ‘ˆ‡ˆ‚kt‚‚†zujgqz‚„„{{{}qy|o{whYSfjp€~|bo|wdioon_Ymkswr]bjKYuu}qj^[emoj`agiegdv„|k +w[^UTFQ[^[RKMKRqTRO`fb\T\B7867SPXT`ULOFBM?@FM0N3(0Cd[dc\\5(HUH!-*A8HVSZeYR$ +=7%B>,-D`aY=/+OTOJ +9eJT`M@a|k\P_SWYUVƒwsgrvŒ’•Ÿ³±—š˜˜š•—£œž¢££§©š¬šŠ§š†ƒ˜“•—•““•••”’’ŒŒ„‡ŒŽŽŒŠ‰ƒ`x€†‰ƒ‡‚h]qvxurorwttz|€j_f[Unrƒ†~€fs€‚`fr{ycXcuolvamiHTkdhkmenhnvsfbnmlqhiiiYm{h^f\O\ba][VMIMVPHLPTOSKLNOLWRNHWNO=ORRNED18C)A +$2*.WeacK4$@=1$7:;JbR_WR)6QSH1*.%34[NSSE757IYX^qaC_`HQawbDGWbbFXQnvlk}ƒ„ˆŒ‰ ª­™—¢­¡”£–¢œ«²«°®©±°€ ŸŽ{˜•’””‘”‹Š}Œ‹ŒŒŽŽ‰†|Z‹Žˆ‚}‡ngu{vxysfuyv€uiszT\{‡rxZcpubivwoasqkl^m\ghDZosxwqgspsrmednpnpn^bf]dnkc]YLYXPU`YMDNYX[SKVMOEP9JVSOOQWH?53$10A3/ +4MC +3&.+"JVQG;$; +55F"E>ZbP\c@.=KKP[L6.=5YFHDJ=G*P]XN?Hb\INccPDHNWFCKZŠ‡p|Š‰‰ˆ‹šž“ƒ¢ª ’Ÿ‚˜«³»ž°¬§Š¥€ž¡¥˜r‘™™•Š‹‹ŠŒ‹‰x††ˆŽŒˆ‹€†Šj| +‚‚Š„seoqlpttqv|yoqoxtSg†‘’xug`bakkriYeuu|ddhel`C_sporkoptpomdmeflmdajk^aaW_UOQZVZ[]SRSSZV[GCBHXR_D5.$#7@>328K$7KW<,03:P;7C=)=':=Mi[Fbb?HNTNG;WPY†vt„‰Š‡„wzŸ‘Ž~•§§©©šš£¢Ÿžœ˜–”k‚‰‰ŠŠ‰ˆ‹‰ˆŒŽ‰‡‹‹‹ +‰•p†‹‰‡„‚lZ\^dnwxuovrmxxenm]x‹’’ztd\aQd_j^XillxhpbYibBgpqtumfplhlekunorjcbe`\aaebfPN_X[dZUQPQ\XZIKCALTaKE?RQR9AHOM<49.,(?Q0OJ7K9;4"4GJ]gkKS@4""8E@GITVELu_;55BTZQ@VXZaxoaQPIRXOFFUXsx‰‰ +‚u€‘š‘Šrl‚‘—™Ÿ€ªš©©§¢¡€›˜’‰j}ˆ +†„†‰ŒŽ +„Š‹€~ŒˆŠŠ‚„†dy‡} + +zndv‚spwwpzwwnlhgubj‰u„{s‰†yb_Olong~}zm{jgf`]XMeehhdXjoomn`Uihehbhhe`TOZ]][Ycf]ZY[[[[X\Vb[VPLG\\HLWMRPHDLj†_B9AIGID?gwPn}gfn‚Œ‹Œ•]~ +“•œ¡¥§®®«¥§«©¢š“Œl~„††‡‡‹ƒˆŽƒˆ‹‡†Š„‡†_‡ +„|zn]n|stml^kblojchzmc~„ƒ‡{‚zjbahi[`qhsj~nib^hQTdcgkdWiqlfigckrrjY^[Z^Y[edZZchgcVg`Z]_]`ZdW\RUGUbJSTJKLKMOLP407COe^9/:3$".% '*?VVU=5VeSNIC_V@^hdtQPEJ0 > HY?AKVROH9IdIR’ƒ[QC=(8VsNQvwe_dtz€ˆ‚hl€’”   ¥§ªª§«©Š¡ž™”‘’t} + +ˆ‡ƒŠŒ‹v€u€€‚‡‡‹‰†‰ŒŠ]‹‡‡Š†ƒw]gtqtn]^jippsq€yag +„wsxz†dv„l`N_gibZicb`[aNU[]aebTegddchjbi\YdjebdX`Z_X\fd\i`Z[[b`V^`eUPRPFKgOTLTFIIIIRKB6/-FrVE94.9=*";av„‹UEZJJ9*C.JezŽm€n;,---6}Š†‚ˆ§lRA +4-%7F6O‰d—­~t|Z* +&6,_]vfcPRY[\V@:Wqt†z]LMYkSG5-]MQT{y{€ƒ€|}vqfn{†‰‘˜ ¥¥¢¥Šš£ Ÿš”–Žr€“ˆ„‡ƒ‚ +ms~„€€}„ + +‰ˆ‹„X| +„sv„ˆy]rzohlqq||‡†~xvnf]RYeu}€xRV\TUhgfhupppngRJGaga^_ni`^RVV\ee`dif]`behbkpm_defid`]adYL[[^SOTPBN^ORWKNROP\\KEA;i‰K55O`ST\TUHJQ^KEFBd™|b@DPLPK7:DQx}ˆ•‹‘‡†;>A,.k'ur`hsŠ‚STœZŠcN\r\`LcWaHp^b\_JRJUfDA\zeE1('7NMYY~ƒz||y€yptrmbxy +“Œ˜¢Ÿ ¡€©¢›–Œ”k}’’ƒe„†Š„|~|€„Š‹‡‚‡w^vv{Œˆ‰uXdwr{€‚„„ƒŒˆ„„}a^qpheqxn\YXcoYk^MMR\gagdgLaU`a\\ZWdX]ebiphdggl^bdpha][_X\^]]`]^W][WLU\YONNNCG]WNQaMCLW:HDCKqƒTBNZf[VQSH]€sš©ºnZf_KF9:9+f‰W^]`[rVY‡—‰hpeIXdzrmN58OqbMIJ37XLR]UaP+ !8]XZUxnt}€}}|qolsb_uuw‚ŒŒ˜Ÿ£šš£Ÿš•’˜•–ƒ‚™”š–uvƒŠƒ††€ƒ}{‚‰ƒ†„„w[jv€‰‰ƒ~qUew‚luww€|‡Œ‹€[TgmlvrdO[_QY]`dgahƒulfuZUHFT^VXdnssnmtqc`bliZ`\\eghdZWemg`kieWVUZ_U[X_]TRN:KJV[ONdU@ZZKHL]Y\k|P7GOY]ULN\tm_Vaf]dt[G@-&Rƒ›¢f]d}fem‰ˆpgxX5Q[qƒVLFYDKT?PV:NWMc}F9V6;8K`V@Af`€~~}|sqdfeW_pwz†Ž‡‹  €œœ—•–œ¢¥£€ž¡ž‰ƒy}‡Ž„ƒ‚‡ƒ„„„ +z +xm[mt€Š„z„mT]k~iimt„Œ‡ +‡‹uR[a]lvaIH`_SQOFSnhffkqugH8/=U`VW`mtsobgoxsjntng]\_`b[_lg^[OY]RRONKMCMO\\LHAANRUMMNTVRdOY]rx„‡~uOLMSWO:Cw™Ÿ‘ibˆƒIE/"-vŠ„][`Trkxrƒ£meTA3jŠrCKV]\MJ>=TOWU_:V5#8^BE8RC1#1j|~ulmojfhf_U]hqˆ‹ +•˜Ÿ¡ ˜ ŸŸ£ž£¢¢št•“„ƒˆp‡Œ„ +†ƒ€~„zw|t\srx{t{y_Mayrp~‰‘–‚‹Š„lQhgbgZK:Y_Yc]F,Juqwjzo[K7ID1biljijihb^\``ipyvwd^dng^`]hf[]\XUY]U]OHEQN[ZRI=NRQRKJIJ[[VXyJ_‘œ•‘w|_WUWPKLT`kx}vjs}}C-:%4Š|sIbcM@f‹‹ki<%H;4Xf~]VNAARM?WrMGTf^?E0'IB<1#02- 2e\Rlkaigjf^bT]ikw~~–œŸ›™š›››™–eˆ|Š€‹‹“‹Œ‰ˆ„ˆƒ†~~u~Œ +m_l{xy}ztnVglr +ƒŠƒxl‹~{gGasxcZ;?SLX]]cOp|tofcPF]eTF@mgicmrxhlpeVeUT_if\cZlmjj\`[X\lkeb]Y\J:G\U\ZXBLTNKNRSOG\dXˆg<}˜•‘~Z_]TMNJ>>B\qts}zero=$3%)+06>Qd`jecabjb^cW^ppt‹—’–—žš™œšœ˜˜–”‘[hƒ’“ƒ‹Œ•’‹ŽŒ‚wyy‚ŠƒeYqz~tv +‰sWf{{{‚wtv +„|yyaWXsfe]Mb\Pd_TfWoog_XTYvzr;:`yhgeditphbeRbg[XW[HNP]c[^WWPP\ecb[UWXR>PUQWQNIUUQHQSUNJLLtB>oVOUXXcG@BR?=A[`ra[‡†“h’r=&-!B¯‡TjKVVeY6[†cD9637;ssTTLCH584KYG?31^FCO''%54;Kgnokmn___da[]hlo„”˜‘’–›ž ˜˜˜˜•ŽXaƒ“”Œ”’Ž‘ŽŒ„‚|‚‡„}‡za`oyu€†Œ~fVk„yxqnzx~ƒ{mgSX^afMZc[_rW[bQc^SbOa{xy]7Rggdgd_izsjdWZfigjZ]]TbXWdl^\\RTQSTSIKKJDYSRZNVSWXMGIKF9JRdN'>LMVM7IADLVG8WŽ„kL[q~scw3'*#QŠŽ ŽENMqlSKZVSPN.9LeH>FK[HKA+&IADGId}E40>n^B" +:,%NRgi_cnphakqtdfltsyƒˆ +ƒ€†‹”ŒŽ‘”˜‘†‡^\‚–‘™Ž’‹zx€‡€x|‰‡†‡}w{€kZdv +†~okV`dfcakmjfs’ŽjhXTY[XB_]Woc`YVSZ`]X^pwxuW_W{{pjurrprphZaYYVSb\f]^Xeeqo|jmaR]X[YNLDOXOXQXZJEDYRSHIk +d@ +!4PeeMM@N@\^chy€|qlphdaox{x‰’™“–˜›—’Š‹‰€pp‡ƒievy|„†‡ˆ‘ +‰‚xownXkslusrpnbQ^sqr€€vf{ŠŠpcnƒ~qZSmfV_RXSLDZeTpmrxhnqIvznibfqgdehpnpUMYaasrcZR[\S]e`^c[mkRXUQLIVX`SZLLDAbKNEn“‰@$ + +.@NNC9>QEDNUKQQQaJMSXid1D8`aSGW3*5O]\jru|wyx~zbWgnr‡‹”›œžž¡ ž›š–Š‚wxiˆ„ˆŽ‘‘Œ•“’—†ƒƒ‚vjpqp[syl{yk`beZmzy +„‚Š‚„u†‚i[k{€ˆWhlaUWMTLDSPTmlmoon\€vUiuvt`[\k„ƒ€rudom|rmƒtcZkdNONPNKUQQPLKOPWU]]URWKI=;XBQV‹”e)##&+B@LA4?MRFGP7K[esJQKShdt`?:F=:bfal‘LPTj`OUYdfZcWRY^E`‡‡gj_zOYJk`.(8&)LMKHODDKOQOIXQOT\GAF?YAYTb~OTL97=6BHXba=hl65I;,49.;]fsllnir‚ +‡nyzw~unt +‹ˆŸšªw™›™˜‰ˆ„‡b‹•Œ’˜‘‹’•†ljtŠƒwtnye€zMkuqtl_grvmho~†‰‚sjWVuoXHX_^OGW_hkBZpsovWrHSxhdlwyc\hkq~ +ˆx”iq[Yldf_YngXTLQVLOURMSUPLFJSTTZ[SKHGUR]<(116211;ANORO@8UQLu„s[GWcaZa],$0!$HNJHHIFS[VIOX7OPXFEECSPwunfRPEBE@;78]}`=QWDB):09PWarsiarv‚†zcuxs{y„~qeqˆ–—‹ƒ‡† +Œ†ƒkvŽ”Ž‹ƒhgn€ +|‚‡‰|]luvzromog_p‡yGRMNcgeejUSqMBb~a6;AogB^em‘wepƒvOkss~bHRrpjtx‚us +w‰{„wuƒ†k^of`lrojkilszf\oqk\SFIDXROOQYGM>.992=-)(,0AOTJNQLF3&A% 93LVU^ITQ8/#)YL=D\BEJBF87HlnRmwPfNOX_P;8KBLFKUKIOYTHJD<8::6+%%+19AE>DLFI*2@:NYPfMaKKUN:=3EX]*#5UWK7ESB?MWY]ic]a`grvttnle~‚yvx’¢£–Œm_ +‹‹ +p~~€ƒ€ekƒ†v[t‚ˆ€ƒƒ‚|v‚ƒ’–vTc‚xywsktz}dmumIGm‚fXfŒqic`NˆˆfN5BOo“Žtmmˆ‰oqbPcyvwttzQhpegilovloww{ƒukovƒy +ur‚€xnn]ifPKGRXPQWkJETOOWbQKJOC8::.)&(%'**9BLEGC,>=+-JWgRX>>:0Z5%BT>N77FFMRXO-zTCzDZG_VEe]7;1,#&'$&4=HOSMRX:HRea\<4=nL39)QH'7;FOPROORE>SBrFS\HHYHZV[]X7KD;OOLE_YS<5#(FTFTIF&F58RVSQff^gjjjkbj|p +ˆ“Žƒji{‰|qim +‚ww†‰hehg~|yxƒ}‡|z +t{]oydcz‚{vuzwwoabpooim^gk^\jSln}ƒŠZ?8>-)+&$2?RVQV`_Z\ZMQ5IRPVISJNL<. +A=>CYNbR`WVQXW\ifengWZYiu‘‰t‡’~„wˆw}‰Šj~kZrwƒŽwZTyvx‚†‰‰–‰‚ƒŽ–|pT^prhbƒ„w}~xkme^uuzofn€•\\_Q‰Ž€Œ™|PSJUn“„|uyŒ„¡›–ŽŽpwxmetxwe`ir{†ufd`auyrŠjmskYVUg\Zqcaba`acreXZLOU]PSWe_YCQHA8;-''('HMZ_^ffRN[CIfZH``JOKYR,57I>*5=;=RNJOVa€€Gl`EABCPVWI>K=DNVwc7?TI2).H*+P?S[EPDIJXrafkj[WYbsy„ˆ{YqˆŠ~o{xv†€xcw +yhZmƒ‚d_k]}ƒ†Š}hjŽˆŠƒyn`rwwub` +srhqƒ}lg~rlsmlVkhN]ƒ +js\KY@NUt„ˆ˜›•Ž~f_uedlpf`kllkjjrpnmknkwut‚||tqhT\``d^ZLX^gbUOSRLJKO9X[WRC>SDD;2'&('.JGUUpolXL\C@nK]YKSTUlN%G9&N#'8@O]ZRORAX{yhlGM89>JYT8AE37`dE53K`B.8A*'?VKGO/MOX\QcOOXYSWdgoloqmQ_gdefjs‰„‡‰yopunhV]ryŠuUuƒ‘†z€†|pz‚qer{~\_qnlasŠœ—‰m\kyu€wsakvNa‰‡xnHQG4]Tkmv€€€€kzma\ƒ{mlq|q +y„iZ^hhdzp}ntqpu‡Š€„xiulXYZNKY[SUZ]YReTRKAC]TLBJN:BB'# ((7P?_jrmdUXZFFGWg^T@FSgQ37<"-),05,/:03L/*275) +*" + +$* + +" + + + + + + + + ebQXY]qzyƒƒ|us^fwxwzvmpnldjjh[fl†dbwxkUrƒ‹ˆ‡ƒ~{u~tf|}‚|~€rbn|€m{ +}|xiX`zt{vcX[ohXc{{\jWdOLmXLUorp +~iqyX>ysqcplhzrpebkjnlms€‡wszjmp‘¢™‘ˆdt]YƒhUV`KNblYX[RNB6152 1024){ + PRINTF("NB_PROCS * NB_CLUSTERS cannot be larger than 1024\n"); + exit(1); + } + if (proc_id >= nglobal_procs){ + PRINTF("processor id %d larger than NB_CLUSTERS*NB_PROCS\n", proc_id); + exit(1); + } + + // Arrays of pointers on the shared, distributed buffers containing the frames + // These arrays are indexed by the cluster index (sized for the worst case : 256 clusters) + unsigned char * A[NB_CLUSTER_MAX]; + unsigned char * B[NB_CLUSTER_MAX]; + + // Arrays of pointers on the instrumentation arrays + // These arrays are indexed by the cluster index (sized for the worst case : 256 clusters) + // each pointer points on the base adress of an array of NPROCS unsigned int + unsigned int * LOAD_START[NB_CLUSTER_MAX]; + unsigned int * LOAD_END[NB_CLUSTER_MAX]; + unsigned int * TRSP_START[NB_CLUSTER_MAX]; + unsigned int * TRSP_END[NB_CLUSTER_MAX]; + unsigned int * DISP_START[NB_CLUSTER_MAX]; + unsigned int * DISP_END[NB_CLUSTER_MAX]; + + // shared buffers address definition + // from the seg_heap_base and increment depending on the cluster index + // These arrays of pointers are identical and replicated in the stack of each task + for (c = 0; c < nclusters; c++){ + A[c] = (unsigned char *) (base + increment * c); + B[c] = (unsigned char *) (base + npixels + increment * c); + LOAD_START[c] = (unsigned int *) (base + 2 * npixels + increment * c); + LOAD_END[c] = (unsigned int *) (base + 2 * npixels + nlocal_procs + increment * c); + TRSP_START[c] = (unsigned int *) (base + 2 * npixels + 2 * nlocal_procs + increment * c); + TRSP_END[c] = (unsigned int *) (base + 2 * npixels + 3 * nlocal_procs + increment * c); + DISP_START[c] = (unsigned int *) (base + 2 * npixels + 4 * nlocal_procs + increment * c); + DISP_END[c] = (unsigned int *) (base + 2 * npixels + 5 * nlocal_procs + increment * c); + } + + PRINTF("NB_CLUSTERS = %d\n", nclusters); + PRINTF("NB_LOCAL_PROCS = %d\n", nlocal_procs); + PRINTF("NB_GLOBAL_PROCS = %d\n", nglobal_procs); + PRINTF("NB_PIXELS = %d\n", npixels); + PRINTF("BLOCK_SIZE = %d\n", block_size); + PRINTF("NB_BLOCKS = %d\n\n", nblocks); + + + PRINTF("*** Starting barrier init at cycle %d ***\n", proctime()); + + // barriers initialization + barrier_init(0, nglobal_procs); + barrier_init(1, nglobal_procs); + barrier_init(2, nglobal_procs); + + PRINTF("*** Completing barrier init at cycle %d ***\n", proctime()); + + // Main loop (on frames) + while (frame < NB_IMAGES){ + // pseudo parallel load from disk to A[c] buffer : nblocks/nclusters blocks + // only task running on processor with (local_id == 0) does it + + if (local_id == 0){ + int p; + + date = proctime(); + PRINTF("\n*** Starting load for frame %d at cycle %d\n", frame, date); + + for (p = 0; p < nlocal_procs; p++){ + LOAD_START[cluster_id][p] = date; + } + if (ioc_read(frame * nblocks + nblocks * cluster_id / nclusters, A[cluster_id], nblocks / nclusters)){ + PRINTF("echec ioc_read\n"); + exit(); + } + if (ioc_completed()){ + PRINTF("echec ioc_completed\n"); + exit(); + } + + date = proctime(); + PRINTF("*** Completing load for frame %d at cycle %d\n", frame, date); + for (p = 0; p < nlocal_procs; p++){ + LOAD_END[cluster_id][p] = date; + } + } + + barrier_wait(0); + + // parallel transpose from A to B buffers + // each processor makes the transposition for (NL/nglobal_procs) lines + // (p,l) are the (x,y) pixel coordinates in the source frame + +#ifndef DISPLAY_ONLY + date = proctime(); + PRINTF("\n*** Starting transpose for frame %d at cycle %d\n", frame, date); + TRSP_START[cluster_id][local_id] = date; + + unsigned int nlt = NL / nglobal_procs; // Nombre de ligne à traiter par processeur + unsigned int first = proc_id * nlt; // Index de la premiÚre ligne à traiter pour le proc courant (celui qui exécute le code) + unsigned int last = first + nlt; // Index de la derniÚre ligne + unsigned int nlines_clusters = NL / nclusters; // Nombre de lignes à traiter par cluster + unsigned int npix_clusters = NP / nclusters; // Nombre de pixels par ligne à traiter par cluster + + for (l = first; l < last; l++){ + PRINTF(" - processing line %d\n", l); + for (p = 0; p < NP; p++){ + unsigned int source_index = (l % nlines_clusters) * NP + p; + unsigned int dest_cluster = p / npix_clusters; + unsigned int dest_index = (p % npix_clusters) * NL + l; + B[dest_cluster][dest_index] = A[cluster_id][source_index]; + } + } + + date = proctime(); + PRINTF("*** Completing transpose for frame %d at cycle %d\n", frame, date); + TRSP_END[cluster_id][local_id] = date; + barrier_wait(1); +#endif + + // parallel display from B[c] to frame buffer + // each processor uses its private dma to display NL*NP/nglobal_procs pixels + + date = proctime(); + PRINTF("\n*** Starting display for frame %d at cycle %d\n", frame, date); + DISP_START[cluster_id][local_id] = date; + + unsigned int npxt = npixels / nglobal_procs; // number of pixels per proc + +#ifndef DISPLAY_ONLY + if (fb_write(npxt * proc_id, B[cluster_id] + npxt * local_id, npxt)){ + PRINTF("[%d]: echec fb_sync_write\n", proc_id); + exit(); + } +#else + if (fb_write(npxt * proc_id, A[cluster_id] + npxt * local_id, npxt)){ + PRINTF("[%d]: echec fb_sync_write\n", proc_id); + exit(); + } +#endif + + if (fb_completed()){ + PRINTF("[%d]: echec fb_completed\n", proc_id); + exit(); + } + + date = proctime(); + PRINTF("*** Completing display for frame %d at cycle %d\n", frame, date); + DISP_END[cluster_id][local_id] = date; + + barrier_wait(2); + + // Instrumentation (done by processor 0 in cluster 0) + if (local_id == 0){ + date = proctime(); + PRINTF("\n*** Starting Instrumentation for frame %d at cycle %d\n\n", frame, date); + + int cc, pp; + unsigned int min_load_start = INT_MAX; + unsigned int max_load_start = 0; + unsigned int min_load_ended = INT_MAX; + unsigned int max_load_ended = 0; + unsigned int min_trsp_start = INT_MAX; + unsigned int max_trsp_start = 0; + unsigned int min_trsp_ended = INT_MAX; + unsigned int max_trsp_ended = 0; + unsigned int min_disp_start = INT_MAX; + unsigned int max_disp_start = 0; + unsigned int min_disp_ended = INT_MAX; + unsigned int max_disp_ended = 0; + + for (cc = 0; cc < nclusters; cc++){ + for (pp = 0; pp < nlocal_procs; pp++){ + if (LOAD_START[cc][pp] < min_load_start){ + min_load_start = LOAD_START[cc][pp]; + } + if (LOAD_START[cc][pp] > max_load_start){ + max_load_start = LOAD_START[cc][pp]; + } + if (LOAD_END[cc][pp] < min_load_ended){ + min_load_ended = LOAD_END[cc][pp]; + } + if (LOAD_END[cc][pp] > max_load_ended){ + max_load_ended = LOAD_END[cc][pp]; + } + + if (TRSP_START[cc][pp] < min_trsp_start){ + min_trsp_start = TRSP_START[cc][pp]; + } + if (TRSP_START[cc][pp] > max_trsp_start){ + max_trsp_start = TRSP_START[cc][pp]; + } + if (TRSP_END[cc][pp] < min_trsp_ended){ + min_trsp_ended = TRSP_END[cc][pp]; + } + if (TRSP_END[cc][pp] > max_trsp_ended){ + max_trsp_ended = TRSP_END[cc][pp]; + } + + if (DISP_START[cc][pp] < min_disp_start){ + min_disp_start = DISP_START[cc][pp]; + } + if (DISP_START[cc][pp] > max_disp_start){ + max_disp_start = DISP_START[cc][pp]; + } + if (DISP_END[cc][pp] < min_disp_ended){ + min_disp_ended = DISP_END[cc][pp]; + } + if (DISP_END[cc][pp] > max_disp_ended){ + max_disp_ended = DISP_END[cc][pp]; + } + } + } + + PRINTF(" - LOAD_START : min = %d / max = %d / med = %d / delta = %d\n", + min_load_start, max_load_start, (min_load_start+max_load_start)/2, max_load_start-min_load_start); + PRINTF(" - LOAD_END : min = %d / max = %d / med = %d / delta = %d\n", + min_load_ended, max_load_ended, (min_load_ended+max_load_ended)/2, max_load_ended-min_load_ended); + + PRINTF(" - TRSP_START : min = %d / max = %d / med = %d / delta = %d\n", + min_trsp_start, max_trsp_start, (min_trsp_start+max_trsp_start)/2, max_trsp_start-min_trsp_start); + PRINTF(" - TRSP_END : min = %d / max = %d / med = %d / delta = %d\n", + min_trsp_ended, max_trsp_ended, (min_trsp_ended+max_trsp_ended)/2, max_trsp_ended-min_trsp_ended); + + PRINTF(" - DISP_START : min = %d / max = %d / med = %d / delta = %d\n", + min_disp_start, max_disp_start, (min_disp_start+max_disp_start)/2, max_disp_start-min_disp_start); + PRINTF(" - DISP_END : min = %d / max = %d / med = %d / delta = %d\n", + min_disp_ended, max_disp_ended, (min_disp_ended+max_disp_ended)/2, max_disp_ended-min_disp_ended); + + PRINTF(" - BARRIER TRSP/DISP = %d\n", min_disp_start - max_trsp_ended); + } + frame++; + + } // end while frame + + PRINTF("*** End of main ***\n"); + + while(1); +} // end main() + +// Local Variables: +// tab-width: 3 +// c-basic-offset: 3 +// c-file-offsets:((innamespace . 0)(inline-open . 0)) +// indent-tabs-mode: nil +// End: + +// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3 + + +