SSCA #3 Sensor Processing Knowledge Formation and Data I/O Serial v1.0

SSCA #3 Sensor Processing Knowledge Formation and Data I/O Serial v1.0
HPCS Productivity Benchmarks Working Group SSCA #3 Sensor Processing Knowledge Formation and Data I/O Serial v1.0 MIT Lincoln Laboratory January 4, 2007 1 1

Outline Scalable Synthetic Compact Applications SSCA #3
Overview Quick Recipe Data I/O Mode Implementation and Results The written spec should answer most questions – and the executable spec show one way how.

Scalable Synthetic Compact Applications Goals
Building on a motivation slide from Fred Johnson (15 January 2004) NextGen Apps Full Apps HPCS Compact Apps APP SIZE/COMPLEXITY Identify which dimensions that must be examined at full complexity and which dimensions that can be examined at reduced scale while providing understanding of both full applications today and future applications Building on the motivational slide from Fred Johnson, it is the goal of HPCS to build Scalable Synthetic Compact Applications that can scale to the size and complexity to design and test Petascale/s systems while being able to control some of the size and complexity to permit system design analysis and testing and programmer productivity testing. We must identify which dimensions that must be examined at full complexity and which dimensions that can be examined at reduced scale while providing understanding of both full applications today and future applications. Erich Strohmaier (LBL) said in his presentation that to drive system development and test future technologies, we need benchmarks with the complexity of micro benchmarks that capture the performance of real applications. For HPCS, we will need to have scalable synthetic compact applications that capture the size and complexity of next generation applications today that have minimal complexity while still providing programming challenges for language developers and sufficient detail to drive architecture development and testing. Micro BMKs SYSTEM SIZE/ COMPLEXITY

HPCS Benchmark Spectrum SSCA #3

Outline The Vision SSCA #3 Implementation and Results Overview
Quick Recipe Data I/O Mode Implementation and Results

Overview SSCA #3 Focuses on two stages:
Front end image processing and storage (Stage 1) Back end image retrieval and knowledge formation (Stage 2) It is representative of many areas: Medical imaging (e.g.: tumor growth) Image many patients daily Later compare images of same patient over time Astronomical image processing (e.g.: monitor supernovae) Image many regions of the sky daily Later compare images of a region over time Reconnaissance monitoring (e.g.: enemy movement) Image many areas daily Later compare images of a given region over time

Overview Benchmark stresses computation, communication, and data I/O
Can be run in 3 modes: System Mode: A combination of Compute & Data I/O Modes Compute Mode (minimized Data I/O Mode) Data I/O Mode (minimized Compute Mode) Principal performance goal is throughput Maximize rate at which answers are generated May overlap operation of data I/O and compute kernels Data I/O and compute kernels may run on different systems Some data is required to be contiguous

SSCA #3 – System Mode Stage 1: Front-End Sensor Processing
Coeffs, Group of Templates Image Pair Stage 1: Front-End Sensor Processing Indices, Stage 2: Back-End Knowledge Formation Validation Raw Data SAR Image Scalable Data and Template Generator Kernel #2 Storage Groups of Detection Sub-Images Grid of Images Detections, Template Indices Kernel #4 Insertion Kernel #3 Retrieval Templates & Pair Kernel #1 Data Read and Image Formation Complex Coeffs Positional Data I/O Computation The architecture of the System Mode involves stressful computational and I/O requirements. However, the benchmark can be run in two other modes that either minimize I/O or computation. Community has traditionally focused on Computation … … but Data I/O performance is increasingly important

SSCA #3 – Compute Mode Sensor Processing Knowledge Formation
SAR Image Knowledge Formation File Raw Template Files Groups of Kernel #2 Storage Detection Kernel #3 Retrieval Sub-Image Sensor Processing Raw SAR Data Files Raw SAR Templates Image Template Insertion Scalable Data and Template Generator Kernel #1 Formation There are 4 major computational components in its Compute Mode. The components are introduced here and discussed in more detail in the subsequent slides. The Scalable Data Generator produces raw SAR data as well as template images that will later be inserted as targets. The raw data is taken into the Image Formation kernel, converted from the temporal to the spatial domain, and interpolated from a polar to a rectangular swath, to form the desired image. The SAR images and target templates are passed to the Template Insertion block where the template targets are pseudorandomly inserted into the SAR image. Next the SAR image with templates is passed to the Detection kernel where, with simple image differencing, thresholding and small correlations, target detections are found and reported. These detections are passed on to a Validation block which requires 100% object recognition with no false positives. <see animation with three left mouse clicks> Validation Detections Kernel #4 Detection SAR Image Pair Templates

SSCA #3: Compute Mode Challenges
Front-End Sensor Processing Back-End Knowledge Formation Raw SAR Templates Image Template Insertion Scalable Data and Template Generator Kernel #1 Formation Validation Detections Kernel #4 Detection SAR Image Templates SAR Image Formation, has large scale parallel two-dimensional (2D) Inverse Fast Fourier Transform (IFFT); may require a ‘corner turn’ or a ‘gather scatter’ (depending on architecture), with large quantities of data. Polar interpolation is known to be even more computationally intense than IFFT. Streaming image data storage to an I/O device (write) may involve large block data transfers, storing one large image after another (Kernel 2) Random location image sequence retrieval from an I/O device (read) also involving large quantities of data, with stressful memory access patterns, and locality issues (Kernel 3) Kernel 4, detection, involves performing many small correlations on random pieces of large images. Many small correlations on selected pieces of a large image Scalable synthetic data generation Pulse compression Polar Interpolation FFT, IFFT (corner turn) Sequential store Non-sequential retrieve Large & small I/O Large Images difference & Threshold

SSCA #3 – Data I/O Mode Stage 1: Front-End Stage 2: Back-End
Image Pair Stage 1: Front-End Group of Small Data Stage 2: Back-End Groups of Large Data Image Scalable Data and Template Generator Kernel #2 Storage Sub-Images Grid of Images Kernel #4 Kernel #3 Retrieval Pair Kernel #1 Data Read and Image Formation Complex The architecture of the System Mode involves stressful computational and I/O requirements. However, the benchmark can be run in two other modes that either minimize I/O or computation.

Ingredients To run Data I/O Mode, the user only needs set:
1) SCALE, 2) N_SDG_GROUPS, and 3) grid Where: SCALE = a parameter that sets the size of raw input data, and image. It should be set so that these are a significant fraction of a single processor’s memory. N_SDG_GROUPS = number of raw input data and templates groups. It should be set large enough to avoid disk cache effects. And the number of images in the grid is: GRID_SIDE_SIZE x GRID_SIDE_SIZE x AV_GRID_DEPTH AV_GRID_DEPTH GRID_SIDE_SIZE

Ingredients Parameters to Code: PICTURE_SIZE = GRID_SIDE_SIZE2
is the number of images in a picture EST_TOT_GRID_SIZE = PICTURE_SIZE x AV_GRID_DEPTH is the total number of times that the input data will be retrieved, and the total number of images stored to the grid mc x n = is the size of the raw complex valued input data mc = 2 x ceil(80 x SCALE) n = 2 x ceil( x SCALE + 60) ROTATION_STEP is the templates’ rotation angle increment in degrees nDistinctLetters x nDistinctRotations is total number of pixelated templates nDistinctLetters = number of least correlated letters in alphabet (21) nDistinctRotations = num of ROTATION_STEP angles between 0 and 360 degs FONT_SIZE x FONT_SIZE = size of a single template in pixels

Ingredients Parameters to Code (Cont.):
m x nx = size of an image m = 2*ceil(mc/ ) k1n = x (1.5 -1/n) kxmin = sqrt( x (m/mc)2) kxmax = sqrt((4 x k1n.^2) x (1/mc)2) nx = 2 x ceil(20 x SCALE*(kxmax-kxmin)/pi) + 20 nSubImages = floor( pOccupancy x p2ndNot1st x (m /(SARLOBE_DISTANCE x FONT_SIZE)) x (nx/(SARLOBE_DISTANCE x FONT_SIZE)) ) = number of smaller images to be stored (by the last kernel), where: pOccupancy = 0.5 is the probability of template occupancy, and p2ndNot1st = 0.5 is the probability that a template appear in the second image but not in the first Total memory required, in bytes = N_SDG_GROUPS x (8 x mc x n + 4 x nDistinctLetters x nDistinctRotations x FONT_SIZE2) + EST_TOT_GRID_SIZE x (4 x m x nx + 4*nSubImages x (4 x FONT_SIZE)2) + (coefficients, support and verification parameters; stored once) Grows with SCALE2

Directions SDG STAGE 1 Create a group
Create a random single precision complex valued (large) mc x n matrix Store the data Create a random real valued (small) FONT_SIZE x FONT_SIZE matrix Store small matrix nDistinctLetters x nDistinctRotations times Copy the above group N_SDG_GROUPS times STAGE 1 for iImage = 1 to EST_TOT_GRID_SIZE KERNEL 1 Randomly pick and retrieve one of the N_SDG_GROUPS groups Create a random single precision real valued m x nx matrix KERNEL 2 Randomly select i and j values in the range [1, GRID_SIDE_SIZE] and use these to create a filename. Store the image matrix end

Directions STAGE 2 for iImageSeq = 1 to PICTURE_SIZE
Randomly select i and j values in the range [1, GRID_SIDE_SIZE] Find the grid depth at this particular point for k = 1 to gridPointDepth-2 KERNEL 3 Retrieve a pair of images, and an SDG group of templates KERNEL 4 for l = 1 to nSubImages Create a random (4 x FONT_SIZE) x (4 x FONT_SIZE) matrix Store the sub image end

SSCA #3 Serial Release v1.0 Types of Data I/O Implemented:
FWRITE, binary, IEEE floating point with appropriate big or little-endian byte ordering and 32-bit data type HDF5, HDF5 32 bit float format Modes: System Mode Includes both Compute (SAR Processing), and Data I/O Modes. Compute Mode Dials the smallest possible Grid of 2 images, thus minimizing data I/O. Data I/O Mode Generates random data, thus foregoing SAR processing. Outputs metrics at each level in the system’s hierarchy – Kernels, Stages, and Overall SSCA #3: Bytes, seconds, bandwidth (bytes/sec)

SSCA #3 Serial Release v1.0 One of many possible implementations
Over 2200 lines of well commented MATLAB code. Carefully picked functional breakdown, data structures, variable names, and comments Coding standard: Modified “Programming in C++, Rules and Recommendations” by Mats Henricson and Erik Nyquist of Ellemtel Telecommunication System Laboratories, Development tools used MATLAB Version (R14) Service Pack 3 (version required) Octave Version 2.9.5 Pentium® GHz CPU with 1.00GB of RAM, and 2.5GB of virtual RAM, running on MS Windows XP Professional Version 2002 Service Pack 1 On a dedicated dual processor hyperthreaded P4 Xeon, 2.8 GHz, ½ MB cache, GNU/Linux (Redhat 9) Accompanying documentation: Written Specification, and these slides MANIFEST.txt – list of files with brief description README.txt – installation and run time instructions; code overview RELEASE_NOTES.txt – known outstanding issues in current release 2 Sentences describing tests.

SSCA #3 Release v1.0a

Summary Challenges: Status:
Large scale parallel two-dimensional (2D) Inverse Fast Fourier Transform (IFFT); may require a ‘corner turn’ or a ‘gather scatter’ (depending on architecture), with large quantities of data. Polar interpolation is known to be even more computationally intense than IFFT (Kernel 1). Streaming image data storage to a data I/O device (write) may involve large block data transfers, storing one large image after another (Kernel 2). Random location image sequence retrieval from a data I/O device (read) also involving large quantities of data, with possibly stressful spatial or temporal memory access patterns, and locality issues (Kernel 3). Small data I/O in all four kernels. Large data I/O in three of the four kernels. Many small convolutions on random pieces of a large image (Kernel 4). Status: Written and Matlab Executable Specification v1.0 released June 22, 2006 Architecture of Data I/O Mode – Martha Bancroft of Shomo Tech Systems, and Jeremy Kepner Works with Octave 2.9.5 Written Specification – SAR Editor – Glenn Schrader, MIT Lincoln Laboratory C version based on release v1.0a (unofficial) – Meng-Ju of UMD, and Janice Onanian McMahon of USC/ISI

SSCA #3 Backup Slides

SSCA #3 Specification Intent Overview Compute Mode Main Components
Synthetic Scalable Data Generator Kernel 1 — SAR Image Formation Template Insertion Kernel 4 — Detection Validation Data I/O Mode Main Components Kernel 1 — Large & Small Data Retrieval Image Grid Kernel 2 — Image Storage Kernel 3 — Image Retrieval Kernel 4 — Small Image Storage

The Vision ― Scalable Synthetic Compact Applications
Bridge the gap between scalable synthetic kernel benchmarks and (non-scalable) real applications, and become an important benchmarking tool Is representative of real application workloads while not being numerically rigorous memory access characteristics communications characteristics I/O characteristics Multi-processor compact application, designed to be easily scalable and verifiable No limits on the distribution to vendors and universities SSCAs represent a wide spectrum of potential HPCS Mission Partner applications The vision of SSCAs is both for development and execution analyses.

Executable Specification
What is an Executable Specification: It implements the Written Specification, illustrating all specified properties; it is just one of many possible implementations It provides developers further insight into the corresponding Written Specification It is a tool for developers with which to validate their own work It includes a serial version, and may include one or more approaches to a parallel version It must be easily readable and intelligible, through its choice of functional structure, variable names, comments, and supporting documentation Structure: Scalable Data Generator Creates synthetic data that can be scaled to stress any computer from a single workstation to a petascale multiprocessor Kernels – timed computational algorithms Verification – checks the correctness of select results Validation – validates the resulting solution 2 Sentences describing challenges.

SSCA #3 – Compute Only Mode
SAR Image Knowledge Formation File Raw Template Files Groups of Kernel #2 Storage Detection Kernel #3 Retrieval Sub-Image Sensor Processing Raw SAR Data Files Raw SAR Templates Image Template Insertion Scalable Data and Template Generator Kernel #1 Formation There are 4 major computational components in its Compute Mode. The components are introduced here and discussed in more detail in the subsequent slides. The Scalable Data Generator produces raw SAR data as well as template images that will later be inserted as targets. The raw data is taken into the Image Formation kernel, converted from the temporal to the spatial domain, and interpolated from a polar to a rectangular swath, to form the desired image. The SAR images and target templates are passed to the Template Insertion block where the template targets are pseudorandomly inserted into the SAR image. Next the SAR image with templates is passed to the Detection kernel where, with simple image differencing, thresholding and small correlations, target detections are found and reported. These detections are passed on to a Validation block which requires 100% object recognition with no false positives. <see animation with three left mouse clicks> Validation Detections Kernel #4 Detection SAR Image Pair Templates

Spotlight SAR Principal performance goal is throughput (rate at which answers are produced by a supercomputer). Overlapping IO and computing is allowed. Intent of the Compact Application: Scalable – operates on a range of systems, from workstation to petascale computer High compute fidelity – representative computations of SAR processing Low physical fidelity – not a full spotlight SAR system (reduces unneeded benchmark complexity) Self-verifying Benchmark is serial (sequential processing), and must be parallelizable.

Compute Mode - SAR Overview
Radar captures echo returns from a ‘swath’ on the ground Notional linear FM chirp pulse train, plus two ideally non-overlapping echoes returned from different positions on the swath Summation and scaling of echo returns realizes a challengingly long antenna aperture along the flight path Synthetic Aperture, L Fixed to Broadside . . . The Scalable Synthetic Data Generator produces raw SAR data approximating what would be obtained from a real SAR system. As an airplane flies adjacent to the field of interest or ‘swath,’ pulse trains are transmitted. The echo returns are scaled (to mimic different reflection coefficients at various points on the swath) and time delayed (to mimic different times at which echoes are returned from different points on the swath) and summed. The size of the SAR synthetic aperture is then determined by the distance that the sensor flies while the radar is capturing returns from the ground; this realizes a challengingly long antenna aperture length. To alleviate its coding complexity, the benchmark makes some simplifications of the SAR problem (which are shown in red): Broadside only processing (instead of being able to process different angular looks) Its synthetic aperture is set equal to its swath’s cross-range Range, X = 2X0 delayed transmitted SAR waveform reflection coefficient scale factor, different for each return from the swath Cross-Range, Y = 2Y0 received ‘raw’ SAR

Scalable Synthetic Data Generator
Generates synthetic raw SAR complex data Data size is scalable to enable rigorous testing of high performance computing systems User defined scale factor determines the size of images generated Generates ‘templates’ that consist of rotated and pixelated capitalized letters Cross-Range Range Spotlight SAR Returns The raw complex data generated by the Data Generator is scalable. A user defined scale factor determines the size of the ‘swath’ that an echo return is gathered from, determining the size of the images generated. This allows the user to scale data sizes to better stress high performance systems. Along with the raw complex SAR data, target templates are generated that consist of rotated pixelated capitalized letters. The templates will be passed on so that later they can be inserted as random targets into the raw SAR images; these templates are also passed on to the Detection kernel.

Kernel 1 — SAR Image Formation
Spatial Frequency Domain Interpolation s(w,ku) f(x,y) F(kx,ky) Interpolation kx = sqrt(4k2 –ku2) ky = ku Matched Filtering Fourier Transform (t,u)B(w,ku) Inverse Fourier Transform (kx,ky) B (x,y) s*0(w,ku) s(t,u) Received Samples Fit a Polar Swath Processed Samples Fit a Rectangular Swath f o kx ky Spotlight SAR Reconstruction Cross-Range, Pixels The SAR image formation step, kernel 1, consists of: fast Fourier transform (FFT) into the frequency domain - to ease processing further down the processing chain pulse compression (also called matched filtering) – to remove the transmitted waveform’s spectral components spatial frequency domain interpolation – to change the swath’s representation from a polar to rectangular coordinate system and two-dimensional inverse fast Fourier transform (IFFT) – to produce an observable spatial-domain image The synthesized SAR image displays a grid pattern of lobes corresponding to what would have been the placement of reflectors on the swath. Range, Pixels

Template Insertion ( not timed)
Inserts rotated pixelated capital letter templates into each SAR image Non-overlapping locations and rotations Randomly selects 50% Used as ideal detection targets in Kernel 4 Hypothetical %100 Insertion of Templates Image Inserted with only %50-Random Templates The template insertion step inserts pixelated rotated capital letter templates into the SAR image: these letters are the “targets” that will later be detected. Templates are placed at and non-overlapping locations and rotations (to later forgo image alignment problems), and in the valleys of the SAR lobes. Template magnitude is set to the average power of the original raw SAR data (well below the magnitude of the SAR peaks). [To make them visible, template magnitude is shown here is exaggerated.] Y Pixels Y Pixels X Pixels X Pixels

Kernel 4 — Detection Detects targets in SAR images
Image difference Threshold Sub-regions Correlate with every template  max is target ID Computationally difficult Many small correlations over random pieces of a large image Requires 100% recognition and no false alarms including objects that cross distributed memory boundaries Image A Image Difference Thresholded Sub-region Correlated The detection kernel compares two images to detect changes that represent moving targets. Two images are differenced, effectively removing the SAR components. 1. If SAR reflector peaks are not formed (e.g.: under focused or blurred), templates may be irrecoverably buried in the blurred SAR image. 2. If SAR reflector peaks are not well formed (floor-to-peak power ratio, and placement) part/all of a template could be irrecoverably buried under a SAR lobe (so it becomes unidentifiable). Image is threshold, to distinguish newly visible targets from targets that moved out of the picture and thus ceased to be of interest. Image is broken-up into sub-regions; each region is correlated against each template; max correlation decides the target’s ID. Requirement: Throughput cannot be meaningfully measured until 100% recognition and no false alarms is achieved. Image B

Computational Challenges
Front-End Sensor Processing Back-End Knowledge Formation Raw SAR Templates Image Template Insertion Scalable Data and Template Generator Kernel #1 Formation Validation Detections Kernel #4 Detection SAR Image Templates SAR Image Formation, has large scale parallel two-dimensional (2D) Inverse Fast Fourier Transform (IFFT); may require a ‘corner turn’ or a ‘gather scatter’ (depending on architecture), with large quantities of data. Polar interpolation is known to be even more computationally intense than IFFT. Streaming image data storage to an I/O device (write) may involve large block data transfers, storing one large image after another (Kernel 2) Random location image sequence retrieval from an I/O device (read) also involving large quantities of data, with stressful memory access patterns, and locality issues (Kernel 3) Kernel 4, detection, involves performing many small correlations on selected pieces of large images. Many small correlations on selected pieces of a large image Scalable synthetic data generation Pulse compression Polar Interpolation FFT, IFFT (corner turn) Sequential store Non-sequential retrieve Large & small IO Large Images difference & Threshold

SSCA #3 – Data I/O Mode Stage 1: Front-End Stage 2: Back-End
Image Pair Stage 1: Front-End Group of Small Data Stage 2: Back-End Groups of Large Data Image Scalable Data and Template Generator Kernel #2 Storage Sub-Images Grid of Images Kernel #4 Kernel #3 Retrieval Pair Kernel #1 Data Read and Image Formation Complex The architecture of the System Mode involves stressful computational and I/O requirements. However, the benchmark can be run in two other modes that either minimize I/O or computation.

Scalable Synthetic Data Generator
Generates large complex data, and groups of small data. Writes a ‘dialed’ number of large complex data to external memory. For each large data, it writes a group of small data to external memory. Single precision Not timed Scalable Data Generator Kernel #1 Large Data Groups of Small Data Large Complex Data Associated Groups of Small Data

Kernel 1 — Data Retrieval
Randomly reads one large complex data from external memory, at each Stage 1 pass. Also reads associated group of small data from external memory, at each Stage 1 pass. Generates a single precision random image (of the size dialed by SCALE). I/O is timed Stage 1: Front-End Kernel #1 Data Read Image Large Data Small Data In FILE_IO mode, also creates a random image at each sensor processing pass. Large Complex Data Associated Groups of Small Data

Image grid, shown scaled to 80 images
External memory image Grid is accessed by Kernels 2 & 3. It is scalable by image size, number of images. Image size requires a non-trivial amount of memory. Intended for dealing with enormous quantity of data, with simultaneous reads and writes. AV_GRID_DEPTH Image Grid GRID_SIDE_SIZE GRID_SIDE_SIZE Image grid, shown scaled to 80 images

Kernel 2 — Image Storage Stage 1: Front-End Writes a different image to a random location in the external memory on the Grid at each Stage 1 pass. Images may be stored together, or in separate pieces (to allow simultaneous reading/writing of the same image). I/O is timed Kernel #2 Image Storage Image Image Images in Grid Computes filenames and addresses, and writes streaming data to random locations on Grid at each Stage 1 Front-End processing pass.

Kernel 3 — Image Retrieval
Images In Grid Templates Group of small data Image Kernel #3 Image Retrieval Image Pair Stage 2: Back-End Image Grid From a random location in the Grid, it computes the address of an image sequence and reads a pair of its images until it reaches its full depth, at each Stage 2 pass. An image sequence is read through its entire Grid’s Depth. Also reads a group of small data at each Stage 2 pass. I/O is timed

Kernels 2 and 3 Additional notes:
If an optimal scheme is picked for data storage, it may not be optimal for data retrieval, and vice versa. “Read behind Write” is allowed. Kernel 2 Image Output Kernel 3 Image Pair Input

Kernel 4 — Small Image Writes labeled sub-images. This is repeated for each image pair, at each grid point, at each Stage 2 pass. I/O is timed Sub-Images Sub-Image Image pair Kernel #4 Small Image Output Stage 2: Back-End

References Carrara, Walter G., Ron S. Goodman and Ronald M. Majewski, Spotlight Synthetic Aperture Radar: Signal Processing Algorithms. Boston: Artech House, 1995. Corlander, John C. and Robert N. McDonough, Synthetic Aperture Radar: Systems and Signal Processing. New York: Wiley, 1991. Haney, R., Meuse T., Kepner, J., and Lebak, J., The HPEC Challenge Benchmark Suite, High Performance Embedded Computing Conference, Lexington, MA 2005. Jakowatz, Charles V., Jr., et al., Spotlight-Mode Synthetic Aperture Radar: A Signal Processing Approach. Boston Kluwer Academic Publishers,1996. Rihaczek, August W., Principles of High-Resolution Radar. Boston: Artech House Originally published: New York: McGraw-Hill, 1969. Stimson, George W., III, Introduction to Airborne Radar Second Edition. World Color Book Services, 1998.

SSCA #3 Sensor Processing Knowledge Formation and Data I/O Serial v1.0

Similar presentations

Presentation on theme: "SSCA #3 Sensor Processing Knowledge Formation and Data I/O Serial v1.0"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

SSCA #3 Sensor Processing Knowledge Formation and Data I/O Serial v1.0

Similar presentations

Presentation on theme: "SSCA #3 Sensor Processing Knowledge Formation and Data I/O Serial v1.0"— Presentation transcript:

Similar presentations

About project

Feedback