Project aangeboden door. Ben Motmans, Brecht Kets en Sam Van Broeck

Project aangeboden door Ben Motmans, Brecht Kets en Sam Van Broeck voor het behalen van de graad van Bachelor in de Multimedia en Communicatie Technologie Academiejaar 2005-2006

Inhoudsopgave Inhoudsopgave ......................................................................................... 3 Dankwoord ............................................................................................ 18 Voorwoord ............................................................................................. 19 Projectdefinitie ....................................................................................... 20 De visie: uw eigen applicatie als benchmark!............................................ 22 Inleiding ................................................................................................ 23 Wat is benchmarking?........................................................................... 23 Problemen met benchmarks................................................................... 23 Methodologie bij database-benchmarks ................................................... 23 TPC ................................................................................................. 23 Heimdall / Sheridan ........................................................................... 23 De resultaten....................................................................................... 24 Build environment ................................................................................ 24 Unit testing ......................................................................................... 25 Versiebeheer ....................................................................................... 25 Code guidelines ................................................................................... 26 Syntax ............................................................................................. 26 Algemeen................................................................................................ 26 Accolades & Indentatie.............................................................................. 26 Witruimte................................................................................................ 27

Naamgeving ..................................................................................... 27 Pascal case.............................................................................................. 27 camel case .............................................................................................. 27

Structuur ......................................................................................... 28 Casting ................................................................................................... 28 Events .................................................................................................... 28 Multi-threading ........................................................................................ 29 Using...................................................................................................... 29

Documentatie ................................................................................... 29 Logging Framework .............................................................................. 29 Assembly Generator ............................................................................. 30

Waarom dynamische code .................................................................. 30 Dynamisch code genereren ................................................................. 30 Reflection.Emit.................................................................................. 31 Voorbeeld................................................................................................ 31 Voordelen................................................................................................ 31 Nadelen .................................................................................................. 31 Conclusie ................................................................................................ 31

CodeDom ......................................................................................... 32 Voorbeeld................................................................................................ 32 Voordelen................................................................................................ 32 Nadelen .................................................................................................. 32 Overzicht ontbrekende onderdelen CodeDom................................................ 32 Conclusie ................................................................................................ 33

Refly................................................................................................ 34 Voorbeeld................................................................................................ 34 Voordelen................................................................................................ 34 Nadelen .................................................................................................. 34 Conclusie ................................................................................................ 34

Mono.Cecil........................................................................................ 35 Sheridan.AssemblyGenerator .............................................................. 36 Kort code voorbeeld.................................................................................. 36

Benchmark ....................................................................................... 37 Resultaten............................................................................................... 37

Conclusie ......................................................................................... 37 Heimdall ................................................................................................ 38 Mythologie .......................................................................................... 38 Algemeen............................................................................................ 38 DbConn .............................................................................................. 38 BenchDB 2005 ..................................................................................... 42 Heimdall ............................................................................................. 44 Features ............................................................................................. 44 Parameters ......................................................................................... 45 Concurrency ..................................................................................... 45 Requests .......................................................................................... 45 Precision .......................................................................................... 45

Test opzetten met MySQL...................................................................... 45 Voorwaarden client ............................................................................ 45 Voorwaarden server........................................................................... 45 My.cnf restoren ................................................................................. 45 Waarden Controleren ......................................................................... 46 Database terugplaatsen...................................................................... 46 Via sql .................................................................................................... 46 Via Datafiles ............................................................................................ 46

Externe Toegang instellen................................................................... 47 Testen ............................................................................................. 47 Test opzetten met PostgreSql ................................................................ 48 Voorwaarden client ............................................................................ 48 Voorwaarden server........................................................................... 48 Installatie ......................................................................................... 48 Postgres gebruiker aanmaken ............................................................. 52 Data herstellen ................................................................................. 52 Kernel-parameters wijzigen ................................................................ 53 Instellingen wijzigen .......................................................................... 53 Gebruikers aanmaken ........................................................................ 55 Server starten................................................................................... 55 Testen ................................................................................................ 55 Sheridan................................................................................................ 56 Algemeen............................................................................................ 56 Voor wie ?........................................................................................... 56 Hoe te gebruiken ? ............................................................................... 57 Algemeen ......................................................................................... 57 Solution ........................................................................................... 57 Project ............................................................................................. 57 Connection ....................................................................................... 58

Structure.......................................................................................... 60 Import Sql statements ....................................................................... 60 Manuele aanpassingen ....................................................................... 63 Performance Monitor.......................................................................... 64 Benchmark ....................................................................................... 64 Connection Manager .......................................................................... 66 Query editor ..................................................................................... 66 Addin Manager .................................................................................. 67 Log viewer........................................................................................ 68 Structuur ......................................................................................... 68 Sheridan.Core...................................................................................... 69 Algemeen ......................................................................................... 69 Auteurs............................................................................................ 69 Licentie ............................................................................................ 69 Introductie ....................................................................................... 69 Addin Bestanden ............................................................................... 70 AddIn ..................................................................................................... 70 Manifest .................................................................................................. 70

Standaard Doozers ............................................................................ 71 Class ...................................................................................................... 71

Standaard Condities........................................................................... 71 Compare ................................................................................................. 71

Sheridan.Base ..................................................................................... 73 Solutions.......................................................................................... 73 AddinTreeView .................................................................................. 73 TreeBuilder....................................................................................... 74 TreeNodeChain ................................................................................. 74 TreeNodeContext............................................................................... 75 TreeNodeBuilder................................................................................ 75 TreeNode Context Menu ..................................................................... 76

Hernoemen van de TreeNode .............................................................. 76 Dubbelklik Event ............................................................................... 76 TreeNodeBuilders registreren .............................................................. 76 Concreet Voorbeeld ........................................................................... 77 Code Editor ...................................................................................... 79 Gui Dispatcher .................................................................................. 79 Validating Control Group..................................................................... 79 Sheridan.Gui ....................................................................................... 81 Algemeen ......................................................................................... 81 Workbench ....................................................................................... 81 Workbench Layout ............................................................................. 81 LogViewer ........................................................................................ 81 Solution Explorer ............................................................................... 82 Welcome Page .................................................................................. 83 Bug Panel......................................................................................... 84 Sheridan.Database ............................................................................... 85 Database Schema.............................................................................. 85 Connection Provider ........................................................................... 86 Connection Pool ................................................................................ 86 Pooled Commands ............................................................................. 87 Ondersteunde Databases .................................................................... 88 Sql Parser ........................................................................................... 89 ANTLR ............................................................................................. 89 Wat is ANTLR ........................................................................................... 89 Waarom hebben we voor Antlr gekozen? En wat zijn de alternatieven ?............ 90 Grammar overerving................................................................................. 91 Waarvoor gebruiken we het ?..................................................................... 91 Uitgebreide beschrijving ............................................................................ 91 Gebruik in Visual Studio ............................................................................ 91

Waarom? ......................................................................................... 94 Verschillende Dialecten ...................................................................... 95

MySql ..................................................................................................... 95 PostgreSql............................................................................................... 95

SQL:1999 Overview.............................................................................. 96 Introductie ....................................................................................... 96 Notatie............................................................................................. 96 Bronnen ........................................................................................... 96 Literals ............................................................................................ 97 Strings.................................................................................................... 97 Numbers ................................................................................................. 97 Hexadecimal ............................................................................................ 97 Binary..................................................................................................... 97 Time....................................................................................................... 98 Constante literals ..................................................................................... 98

Commentaar..................................................................................... 98 Enkele lijn ............................................................................................... 98 Meerdere lijnen ........................................................................................ 98

Operatoren ....................................................................................... 98 Wiskundig ............................................................................................... 98 Numerieke vergelijking.............................................................................. 98 Vergelijking ............................................................................................. 99 Logisch ................................................................................................... 99 Andere.................................................................................................... 99

Data types........................................................................................ 99 Character ................................................................................................ 99 Numeric .................................................................................................. 99 Decimal .................................................................................................. 99 Integer ................................................................................................... 99 Float..................................................................................................... 100 Time..................................................................................................... 100 Andere.................................................................................................. 100

Statements......................................................................................100 Select ................................................................................................... Insert ................................................................................................... Update.................................................................................................. Delete .................................................................................................. Truncate ............................................................................................... Drop.....................................................................................................

100 100 101 101 101 101

Clauses ...........................................................................................101 From .................................................................................................... Where .................................................................................................. Having .................................................................................................. Group By .............................................................................................. Order By ............................................................................................... As ........................................................................................................ Join ...................................................................................................... Union ...................................................................................................

101 101 102 102 102 102 102 102

Predicates .......................................................................................102 Limit..................................................................................................... 102 Like ...................................................................................................... 102

Functies ..........................................................................................102 CAST .................................................................................................... 102

Data Aggregatie ...............................................................................102 AVG ..................................................................................................... COUNT.................................................................................................. SUM ..................................................................................................... MIN ...................................................................................................... MAX ..................................................................................................... STDDEV ................................................................................................ VARIANCE .............................................................................................

102 102 103 103 103 103 103

Wiskundig .......................................................................................103 ABS...................................................................................................... CEIL ..................................................................................................... FLOOR .................................................................................................. ROUND ................................................................................................. SQRT....................................................................................................

103 103 103 103 103

Text ...............................................................................................104 LENGTH ................................................................................................ LEFT ..................................................................................................... RIGHT .................................................................................................. SUBSTR ................................................................................................

104 104 104 104

Date and Time .................................................................................104 CURRENT_DATE ..................................................................................... CURRENT_TIME...................................................................................... DATE .................................................................................................... DAY...................................................................................................... MONTH ................................................................................................. WEEKDAY.............................................................................................. YEAR ....................................................................................................

104 104 104 104 104 104 104

Identifiers .......................................................................................105 Identifier grootte .................................................................................... 105 Identifier name ...................................................................................... 105 Quoted identifiers ................................................................................... 105

QueryScript ........................................................................................106 Wat is QueryScript............................................................................106 Ontstaan ............................................................................................... 106 Structuur .............................................................................................. 106

Taal specificaties ..............................................................................106 Referenties ......................................................................................106 Afkortingen .....................................................................................106 Grammatica.....................................................................................106

Commentaar....................................................................................107 Literals ...........................................................................................107 Strings.................................................................................................. Numerieke waardes ................................................................................ Booleaanse waardes ............................................................................... Speciale waardes....................................................................................

107 107 108 108

Variabelen .......................................................................................109 Query ................................................................................................... Parameter ............................................................................................. Row...................................................................................................... Var.......................................................................................................

109 109 109 109

Expressies .......................................................................................110 Wiskundige expressies ............................................................................ Vergelijkende expressies ......................................................................... Booleaanse expressies ............................................................................ Execute ................................................................................................ Get ......................................................................................................

110 110 110 111 111

Statements......................................................................................112 Debug .................................................................................................. Status .................................................................................................. Toekenning ........................................................................................... Set parameter ....................................................................................... Foreach ................................................................................................ While.................................................................................................... If / Else If / Else.....................................................................................

112 112 112 112 112 113 113

Inline Code ......................................................................................113 Expressies ............................................................................................. 113 Statements............................................................................................ 114

Voorbeeld........................................................................................114 Compiler .........................................................................................114 Dynamic Code..................................................................................115 Application Domain Assembly Resolve ....................................................... 115

Sheridan.Monitoring ............................................................................116 Client monitoring..............................................................................116 Sheridan monotoring SIMC Protocol ....................................................116 Werking ................................................................................................ 116

Punt Komma delimited protocol ..........................................................117 Éénmalige info opvragen ......................................................................... Informatiestroom starten......................................................................... Informatiestroom stoppen ....................................................................... Soorten informatiestromen ...................................................................... Foutieve data......................................................................................... Config files ............................................................................................

117 117 117 117 118 118

XML Soap Protocol ............................................................................119 Balvenie.............................................................................................121 Wat is Balvenie?..................................................................................... Waarom C++ ? ...................................................................................... Mogelijkheden........................................................................................ Naar de toekomst...................................................................................

121 121 121 121

Sheridan.Threading .............................................................................123 Algemeen ........................................................................................123 Functies ..........................................................................................123 Voorbeeld........................................................................................123 Monitoring .......................................................................................123 Threading in Londen .........................................................................125 Locatie.................................................................................................. 125 Programma ........................................................................................... 125

Why does Intel care about software ....................................................125 De drie pijlers ..................................................................................125 Creatie.................................................................................................. 125 Testen .................................................................................................. 125 Optimalisatie ......................................................................................... 125

Multithreading, Testcases ..................................................................126 Oracle................................................................................................... 126 CERN.................................................................................................... 126 Kaspersky ............................................................................................. 126

Waarom multithreading .....................................................................126 Multicore opportunity: Developers in transition .....................................126 Algemeen.............................................................................................. Niets doen............................................................................................. Het potentieel ........................................................................................ Voordelen..............................................................................................

126 127 127 127

Intel Software: Optimizing application performance...............................127 Algemeen.............................................................................................. VTune................................................................................................... OpenMP ................................................................................................ MPI ......................................................................................................

127 127 127 128

Best practices: Customer design wins..................................................128 Scaling threading for multicore methodology demonstration ...................128 Public Relations .....................................................................................129 Vormgeving........................................................................................129

Stripverhaal .......................................................................................130 Promotie affiche ..................................................................................131 Brochure............................................................................................132 Database Optimalitaties ..........................................................................134 MySQL...............................................................................................134 Algemeen ........................................................................................134 Versies............................................................................................134 Installatie ........................................................................................135 Onder Gentoo ........................................................................................ Onder Suse ........................................................................................... RPM Package Manager ............................................................................ Basisrechten instellen .............................................................................

135 135 135 135

Database terugplaatsen.....................................................................136 SQL-backup........................................................................................... 136 Datafiles ............................................................................................... 136

Externe toegang...............................................................................137 Engines...........................................................................................138 Algemeen.............................................................................................. 138 MyISAM ................................................................................................ 138 InnoDB ................................................................................................. 138

Optimalisaties ..................................................................................139 Algemeen.............................................................................................. 139 Indices.................................................................................................. 139 Explain ................................................................................................. 140

Config-waarden................................................................................142 key_buffer_size...................................................................................... table_cache ........................................................................................... sort_buffer_size ..................................................................................... read_buffer_size .................................................................................... read_rnd_buffer_size .............................................................................. query_cache .......................................................................................... max_connections ................................................................................... thread_concurrency ................................................................................ innodb_buffer_pool_size.......................................................................... innodb_additional_mem_pool_size............................................................ innodb_thread_concurrency .....................................................................

142 142 142 142 142 143 143 143 143 143 143

Geheugen bemerking ........................................................................144 Solaris Optimalisaties........................................................................145 Solaris Priocntl .................................................................................145 Renice ............................................................................................145

Schaling ..........................................................................................146 Algemeen.............................................................................................. 146 Mutexes ................................................................................................ 146

Bemerkingen ...................................................................................146 Resultaten .......................................................................................146 PostGreSQL ........................................................................................150 Algemeen ........................................................................................150 Versies............................................................................................150 Installatie ........................................................................................151 RPM Package Manager ............................................................................ 151 Via compilatie ........................................................................................ 151

Postgres gebruiker aanmaken ............................................................154 Database terugplaatsen.....................................................................154 Kernel aanpassingen .........................................................................155 Gebruikers aanmaken .......................................................................155 Server starten..................................................................................156 Optimalisaties ..................................................................................157 Algemeen.............................................................................................. Prepared statements............................................................................... Shared Buffers ....................................................................................... Sort mem.............................................................................................. Max connections..................................................................................... Fsync.................................................................................................... Solaris Priocntl ....................................................................................... Renice .................................................................................................. Schaling................................................................................................ Resultaten.............................................................................................

157 157 157 157 157 157 158 158 158 158

Conclusies ............................................................................................161 Ben Motmans .....................................................................................161 Brecht Kets ........................................................................................162 Sam Van Broeck .................................................................................163 Lijst met afbeeldingen ............................................................................164 Bijlage..................................................................................................167 Verslagen Ben Motmans .......................................................................167 Projectweken – week 1......................................................................167

Projectweken – week 2......................................................................167 Projectweken – week 3......................................................................167 Projectweken – week 4......................................................................168 Stage – week 1 (13 maart – 17 maart)................................................168 Stage – week 2 (20 maart – 24 maart)................................................168 Stage – week 3 (27 maart – 31 maart)................................................168 Stage – week 4 (18 april – 21 april) ....................................................169 Stage – week 5 (24 april – 28 april) ....................................................169 Stage – week 6 (2 mei – 5 mei) .........................................................169 Stage – week 7 (8 mei – 12 mei)........................................................170 Stage – week 8 (15 mei – 19 mei) ......................................................170 Stage – week 9 (22 mei – 26 mei) ......................................................170 Stage – week 10 (29 mei – 2 juni) ......................................................170 Stage – week 11 (5 juni – 9 juni) .......................................................171 Stage – week 12 (12 juni – 16 juni) ....................................................171 Verslagen Brecht Kets..........................................................................172 Weekverslag: Week - 4 (6 - 10 februari) ...................................................172 Opzetten build environment ..................................................................... 172 Opzetten Logging framework LogForNet .................................................... 172 Onderzoek naar opvragen van metadata van verschillende databases. ........... 172

Weekverslag: Week - 3 (13 - 17 februari) ............................................172 Implementatie van DatabaseLibrary .......................................................... 172 Databases ............................................................................................. 172

Weekverslag: Week - 2 (20 - 24 februari) .................................................173 Beslissing om zelf een interim benchmark te schrijven: Heimdall................... MySql ................................................................................................... Installatie van Sybase ............................................................................. Sql parser .............................................................................................

173 173 173 173

Weekverslag: Week - 1 (6 - 10 maart)......................................................173 Updaten Heimdall ................................................................................... Installatie Sybase ................................................................................... Installatie DB2 ....................................................................................... Sheridan ...............................................................................................

173 173 174 174

Weekverslag: Week 1 (13 - 17 maart) ......................................................174

DB2 ..................................................................................................174 Sybase ................................................................................................. Threading.............................................................................................. Algemeen.............................................................................................. Ondersteunen van het Research Team.......................................................

174 174 174 174

Weekverslag: Week 2 (20 - 24 maart) ......................................................174 Sybase ..............................................................................................174 DB2...................................................................................................... 174

Floating Points opvragen tijdens Bert zijn bench ......................................175 Benchmarks .......................................................................................175 Threading ..........................................................................................175 Mogelijkheden van het Threading mechanisme ........................................175 Weekverslag: Week 3 (27 - 30 maart) ......................................................175 Sybase ..............................................................................................175 Programmatie.....................................................................................175 DB2 ..................................................................................................176 MySQL...............................................................................................176 Heimdall ............................................................................................176 Benchmarks .......................................................................................176 Weekverslag: Week 4 (18 - 21 april) ........................................................176 MySQL...............................................................................................176 Vergadering D&N ................................................................................176 Vergadering NSS.................................................................................176 Benchmarks .......................................................................................176 Weekverslag: Week 5 (24 - 28 april) ........................................................177 MySQL...............................................................................................177 C# ....................................................................................................177 C++..................................................................................................177 Benchmarks .......................................................................................177 Weekverslag: Week 6 (2 - 5 mei).............................................................177

MySQL...............................................................................................177 C++..................................................................................................178 Benchmarks .......................................................................................178 DB2 ..................................................................................................178 PostgreSql..........................................................................................178 Weekverslag: Week 7 (8 - 12 mei) ...........................................................178 PostgreSQL ........................................................................................178 DB2 ..................................................................................................178 Suse .................................................................................................178 Heimdall ............................................................................................178 Weekverslag: Week 8 (15 - 19 mei) .........................................................178 Intel ..................................................................................................178 Programmeren....................................................................................179 Software ............................................................................................179 Dolmen..............................................................................................179 Weekverslag: Week 9 (22 - 26 mei) .........................................................179 Sheridan ............................................................................................179 Algemeen...........................................................................................179 Weekverslag: Week 10 (29 mei – 2 juni)...................................................179 Sheridan ............................................................................................179 Weekverslag: Week 11 (5 – 9 juni) ..........................................................179 Sheridan ............................................................................................180 Algemeen...........................................................................................180 Balvenie.............................................................................................180 Weekverslag: Week 12 (12 – 16 juni) .......................................................180 Sheridan ............................................................................................180 Algemeen...........................................................................................180 Stageverslagen Sam Van Broeck ...........................................................181

Weekverslag : Week 1 ............................................................................181 DB2...................................................................................................... Multi-Threading...................................................................................... Heimdall :: drivers.................................................................................. Algemeen..............................................................................................

181 181 181 181

Ondersteunen van het Research Team ivm DB2 .........................................181 Weekverslag : Week 2 ............................................................................181 DB 2..................................................................................................... Registratie eindwerken ............................................................................ Heimdall ............................................................................................... Algemeen.............................................................................................. Grafisch werk ........................................................................................

181 181 181 181 182

Weekverslag : week 3 ............................................................................182 DB 2..................................................................................................... 182 Grafisch werk ........................................................................................ 182 Algemeen.............................................................................................. 182

Weekverslag : week 4 ............................................................................182 DB 2..................................................................................................... Monitoring ............................................................................................. Vergaderingen ....................................................................................... Grafisch werk ........................................................................................

182 182 182 183

Weekverslag : week 5 ............................................................................183 Monitoring ............................................................................................. 183

Weekverslag : week 6 ............................................................................183 Monitoring ............................................................................................. 183 Algemeen.............................................................................................. 183 Bug ...................................................................................................... 183

Weekverslag : week 7 ............................................................................183 Bug ...................................................................................................... 183 Monitoring ............................................................................................. 183

Verdere weekverslagen...........................................................................184 Verslag D&N..........................................................................................185 Athena framework (UTF8) :: Wim Debreuck ............................................185 Werkbenodigdheden ::.........................................................................185 Korte toelichting van het programma GIS VMI Stock simulator: .................185 Hoe een simulatie starten ??? ...............................................................186 Wat is belangrijk voor D&N ...................................................................186

Dankwoord Aan het begin van onze eindverhandeling is een dankwoord op zijn plaats. Vele mensen hebben immers in meer of minder actieve mate bijgedragen aan dit eindwerk. In de eerste plaats willen wij onze promotor, Dhr. Johan De Gelas bedanken voor het bezorgen van al ons materiaal en de technische ondersteuning. Als tweede zouden wij graag onze school, de Provinciale Industriële Hogeschool West-Vlaanderen bedanken voor het ter beschikking stellen van hun lokalen en tal van andere medewerkingen. Ook zouden wij alle leveranciers willen bedanken voor het beschikbaar stellen van hun materiaal. Zonder hen zouden wij geen eindwerk tot stand hebben kunnen brengen. En op de laatste maar zeker niet de minste plaats willen we alle mensen bedanken die ons geholpen hebben zowel op professioneel als op emotioneel gebied. Bedankt iedereen!

Voorwoord In het kader van het PWO1 project "Server Sizing hebben wij samengewerkt met het research team, bestaande uit Bert Devriese, Dieter Saeys en Tijl Deneut. Zij zijn de uiteindelijke gebruikers en bètatesters van Sheridan. Onze tool wordt hierbij ingezet om de schaling van een server te meten via zijn eigen applicatie op een innovatieve, snelle en goedkope wijze. Er is slechts 1 client vereist om de benchmarks uit te voeren. Dit leidt tot een innovatieve kostenverlaging voor het datacentrum, wat zeker in de smaak valt bij de KMO's. Om het belang aan te tonen van dit project, vind je hieronder een illustratie van gegevens verzameld door Gartner. De huidige server hardware markt is goed voor 50 miljard dollar. Database server software is goed voor 15 miljard dollar. Publicaties2 die gemaakt zijn omtrent het onderzoek verricht door het research team worden gemiddeld gelezen door 2,8 miljoen professionele lezers. Om het onderzoek te bevorderen heeft de industrie 106.000 euro voorzien in zowel hard- als software en nog eens 10.000 euro in cursusmateriaal. De overheid voorziet het onderzoek van een 14.000 euro. Als we de reacties moeten samenvatten van externe personen die in contact komen met Sheridan dan is de eerste reactie verbazing en de tweede, "Ik wil dit hebben !!". Graag nodigen wij u uit om verder kennis te maken met Sheridan. Mocht u nog vragen hebben aarzel dan niet om contact op te nemen. Indien u vragen hebt in verband met dienstverlening of het PWO project "Server Sizing" kan u contact op nemen met onze projectleider, Johan De Gelas : [email protected] Ben Motmans, Lead Developer, [email protected] Brecht Kets, Developer en Database Researcher, [email protected] Sam Van Broeck, Developer en Public Relations, [email protected]

1

Projectmatig Wetenschappelijk Onderzoek

2

Unieke IP's geregistreerd op AnandTech.com

Projectdossier Sheridan 20 van 186

Projectdefinitie Een nieuw softwareproject kan de systeembeheerder voor een groot vraagteken plaatsen: is de huidige beschikbare server krachtig genoeg om de nieuwe database software intensief te laten gebruiken? Indien een nieuwe server aangeschaft wordt, in welke hardwarecomponenten moet er extra geïnvesteerd worden om flessenhalzen te voorkomen? Wat als er in de toekomst veel meer of intensiever gebruikt gemaakt wordt van deze applicatie? De softwareontwikkelaar die een goede service wil leveren naar zijn klanten toe heeft soortgelijke vragen: hoe goed schaalt de ontwikkelde database applicatie op de aanwezige servers van de klant? Hoe kan hij of zij hard maken dat de software wel degelijk zal schalen met intensiever gebruik, meer gebruikers of een combinatie van beide? Leveren de aangeprezen optimalisaties in de nieuwste versie werkelijk betere prestaties bij intensief gebruik? De huidige benchmark tools zoals TPC3 kunnen hierop geen antwoord bieden. Omdat deze benchmarks ontworpen zijn om vooral de hardwarefabrikanten en database software vendors de kans te geven om hun product te onderscheiden van de competitie, heeft de gemiddelde systeemadministrator en softwareontwikkelaar geen boodschap aan deze benchmarks. De testmethodes zijn complex, arbeidsintensief, duur en vereisen een heel netwerk van clients. Zelfs al slaagt men erin om de benchmark succesvol uit te voeren, dan zijn de resultaten weinig relevant voor de eigen situatie: de database applicatie gebruikt in de benchmark, wijkt meestal sterk af van het eigen software project.

Figuur 1 : Vergelijking TPC met Sheridan

3

Transaction Processing Performance Council (TPC) is een not-for-profit organisatie welke performance benchmarks uitvoert voor IT applicaties, zoals bijvoorbeeld databases. Meer info op : http://www.tpc.org


Het PWO project “Sizing Servers” wil nieuwe methodologieën en softwaretools (Sheridan) aanreiken die een antwoord bieden op bovenstaande vragen.

Figuur 2 : Visie van Sheridan


De visie: uw eigen applicatie als benchmark! Sheridan is gemakkelijk te gebruiken en levert met een minimale tijdsinvestering zowel relevante als toekomstgerichte resultaten. Concreet betekent dit: Relevant: de SQL log van uw eigen database applicatie wordt gebruikt als benchmark. De resultaten zijn dus een weerspiegeling van uw eigen gebruik van uw eigen database applicatie. Andere protocollen voor communicatie naar de server zoals SOAP (XML) worden ook ondersteund. Gebruiksgemak: één krachtige portable is voldoende als client. U loopt naar uw server, verbindt uw portable rechtstreeks aan de server en u start de test. Lokalen met een tientallen test clients zijn overbodig. Minimale tijdsinvestering: de testen duren meestal maximaal een tiental tot enkele tientallen minuten. Toekomstgericht: Onze software simuleert steeds meer gebruikers, zodat u naderhand kan inschatten wat het maximaal aantal gebruikers is dat uw huidige server aankan met degelijke responstijden. Zo krijgt u een idee hoe toekomstige belastingen aangepakt moeten worden. Sheridan ondersteunt applicaties op basis van MySQL, PostgreSQL, MS SQL Server, IBM DB2 en Sybase. Oracle zal in de toekomst aan deze lijst toegevoegd worden. Ondersteunde server operating systemen zijn op dit moment Linux (Kernel 2.6.x), Windows 2003 en Solaris. Het client programma zelf vereist een Windows XP client.


Inleiding Wat is benchmarking? In de computerwereld is een benchmark een methode om de prestaties van verschillende systemen, softwares en andere te vergelijken. Daar hardwarefabrikanten voortdurend betere en snellere machines ontwikkelen, zijn benchmarks een manier om deze onderling te vergelijken. Om een zo objectief mogelijke vergelijking te maken, bestaan er standaardoplossingen, zoals het getal pi berekenen tot x-aantal cijfers na de komma. In de wereld van de grafische kaarten bestaan er ook benchmarks zoals 3Dmark. Benchmarks maken het niet alleen mogelijk om hardware te testen, maar ook om software te vergelijken. Een voorbeeld hiervan zijn database-servers die met TPC getest worden.

Problemen met benchmarks Er zijn enkele problemen met de huidige benchmarks. Ten eerste zijn sommige benchmarks duur qua resources en tevens duur qua technische bagage. Voor een voorbeeld denk ik onmiddellijk aan TPC. Niet dat de licentiekost hier zo groot is (er zijn namelijk ook gratis benchmarktools), maar de ingebruikname wel. Voor TPC heb je namelijk een hele hoop testclients nodig, samen met een uitgebreid schijfsysteem. Om nog maar niet te spreken van de consulting kosten die hier aan te pas komen. Tevens zijn de resultaten van deze tests niet van toepassing op een bedrijf zijn eigen software. Dit brengt mij tot het tweede probleem. Je hebt geld, je hebt de hardware, de test is voltooid, maar wat nu met deze resultaten? Wat willen ze zeggen. Hoe moet ik ze interpreteren. En belangrijkst: zijn ze vergelijkbaar met MIJN applicatie. Naast onze softwaretool, Sheridan, bestaat er geen enkele andere benchmark die het mogelijk maakt een bedrijf zijn EIGEN applicatie te gebruiken als benchmark. Of dit nu is om software of hardware te testen.

Methodologie bij database-benchmarks TPC De manier waarop TPC een benchmark uitvoert, is als volgt: je simuleert geen honderden clients die verbinding maken naar een database-server, je gebruikt effectief 100 clients die queries uitvoeren op een server. Deze manier klinkt waarschijnlijk logisch, en dat is het ook. Maar welke KMO beschikt over deze resources, enkel en alleen maar om iets als schaling en performantie te weten te komen? Voor een KMO is het dan goedkoper om gewoon de server uit te breiden. Heimdall / Sheridan De manier waarop Heimdall en Sheridan een benchmark uitvoeren is heel verschillend. Heimdall en Sheridan simuleren een aantal gebruikers op 1 client. Of dit er nu 10 of 100 zijn, dit doet er niet toe. Nogmaals gebruik ik mijn voorbeeld van databases. Onze tools gebruiken een ‘tunnel’ om gebruikers te simuleren. Met een tunnel bedoel ik een connectie naar een server die 100% gebruikt wordt. In plaats van 200 clients die af en toe iets sturen naar de


database, gebruiken wij 1 client die via 100 threads evenveel connecties opent naar een database en deze 100% belast. Het nadeel van deze methode is dat je ook moet nakijken of je client niet de bottleneck word.

De resultaten De resultaten zijn natuurlijk heel belangrijk. En niet alleen de resultaten. Nog belangrijker is natuurlijk de reden waarom je deze resultaten krijgt! Dit deel van benchmarking is wetenschappelijk onderzoek. Iedereen kan de resultaten zomaar overnemen, maar indien je de reden waarom niet weet kan je onmogelijk zeggen of deze resultaten correct zijn! Het kan namelijk zijn dat je iets over het hoofd gezien hebt, een tuning parameter vergeten, enz. De boodschap is: ga steeds kritisch te werk!

Build environment Voor we gestart zijn met het ontwikkelen van Sheridan hebben we enkele basic maar toch belangrijke ontwerpbeslissingen moeten nemen om een goede werking van het project te garanderen. We ontwikkelen onze applicatie in C#.Net, vanwege de meer performante compiler (in vergelijking met VB.Net). Als ontwikkelingspakket ontwikkelen we in Visual Studio 2005 Professional. Om de continuïteit van het project te verbeteren kiezen we voor het pakket waarin we standaard ontwikkelen tijdens de lessen. Hierdoor heeft elke opvolgende MCT student geen problemen met het zoeken van software en kent hij ook de mogelijkheden ervan. Hierop aansluitend hebben we beslist om MSBuild van Microsoft te gebruiken als Build Environment. Niet enkel omdat deze mee in de CLR4 gebakken zit, maar ook omdat deze mee geïntegreerd is in Visual Studio 2005. Het feit dat MSBuild ook XML based is, spreekt alleen maar in zijn voordeel. Voor meer informatie in verband met MSBuild verwijzen wij u graag door naar http://lab.msdn.microsoft.com/vs2005/teams/msbuild/default.aspx#top. Wij hebben MSBuild ook kort vergeleken met Not Ant5. Deze heeft volgende voordelen: •

maakt gebruik van handige Task klasses

•

XML based

•

cross platform

•

ondersteunt .Net 1.0, 1.1, 2.0 en Mono 1.0 platforms

•

in staat om zelfstandig andere tasks uit te voeren zoals het runnen van NDoc, tar files aanmaken (zippen), status e-mails versturen en last but not least, het uitvoeren van unit tests.

4

Common Language Runtime

5

Apache Ant is een Java Based build tool : http://nant.sourceforge.net/


Er zijn echter ook nadelen aan deze techniek verbonden waardoor MSBuild onze voorkeur krijgt. •

builden via Visual Studio 2005 is niet mogelijk

•

dependenties tussen verschillende projecten kan problemen geven

Ook is er even gedacht om te werken met MakeFiles, een zeer flexibele build tool die al een tijdje meegaat. Echter deze methode is te complex en werkt recursief, wat lange wachttijden met zich kan meebrengen. Wie meer informatie over deze techniek wil, kan zijn neus opsteken in volgende handleiding: http://www.gnu.org/software/make/manual/make.html

Unit testing Dit is het geautomatiseerd logisch testen van het programma. Er wordt een vast bericht gestuurd naar de te testen klasse en men controleert of het verwachte antwoord terug gezonden wordt. In de praktijk test je eigenlijk de publieke interfaces van je klasse. Nogmaals dit is een louter logische test op flow van je code. Hiermee kan je niet de functionaliteit of het gebruiksgemak testen. Onze test worden gerund via NUnit, een OpenSource unit testing framework voor .Net. Het is de .Net variant van de java based JUnit. NUnit zelf is volledig geschreven in C#.Net om zo optimaal en maximaal gebruik te maken van de performance en handigheden als reflection, custom attributes in het .Net framework.

Versiebeheer Dit is een systeem dat is ontwikkeld om een verzameling (bron) bestanden hiërarchisch te ordenen, bij elkaar te houden en te beheren. Mensen kunnen hun lokale kopie van het hiërarchische systeem up-to-date houden van de versiebeheer server en bovendien is het mogelijk om veranderingen aan bestanden of nieuwe bestanden terug te sturen, net zoals het mogelijk is om oude bestanden te verwijderen.

Hier hebben wij geopteerd voor het iets modernere Subversion System. Als SVN client maken wij gebruik van Tortoise SVN. Hoe je een SVN installeert en gebruiksklaar maakt, lees je op volgende zeer uitgebreide handleiding: http://svnbook.red-bean.com/nightly/en/svn-book.html


Code guidelines Een zeer belangrijk item bij het schrijven van een applicatie, zowel alleen als in teamverband zijn code guidelines. Syntax Algemeen Indentatie met tabs. Accolades & Indentatie Accolades op een nieuwe regel beginnen bij namespace, type, method en property declaraties. class MyClass { int Method () { return 3; } }

Case labels en statements indenteren. switch (name) { case "John": break; }

If-else blokken laten de accolade op dezelfde regel staan. if (a > b) { return 3; } else { return 0; }

Hetzelfde geld voor try-catch blokken. try { // ... } catch (Exception e) { // ... } finally { // ... }

En in zeer kortte if-else blokken laten we de accolades gewoon weg. if (a > b) return 3; else return 0;


Witruimte Een spatie voor de haakjes bij een functiedeclaratie en functieaanroep. void Method () { Console.WriteLine ("In Method"); }

Een spatie voor de haakjes bij control flow statements. if (a > b) // ...

Geen spatie voor vierkante haakjes, zowel bij array declaraties als array index statements. int[] arr = { 1, 2, 3 }; arr[2] = 5;

Parameters krijgen een spatie na het scheidingsteken, zowel bij declaraties als aanroepen. int Sum (int a, int b) { return RealSum (a, b); }

Operatoren worden voorafgegaan en gevolgd door een spatie, om de leesbaarheid te bevorderen. void Method () { for (int i = 0; i < 10; ++i) 1 + 2 – 3 / 4 * 5; }

Naamgeving Een kort overzicht voor hoofdlettergebruik (Microsoft richtlijnen). Pascal case De eerste letter van een woord en de eerste letter van een deelwoord worden met een hoofdletter geschreven. Indien een deelwoord korter is dan 3 tekens wordt het volledige deelwoord in hoofdletters geschreven. Voorbeeld EenVoorbeeld ABVoorbeeld

camel case De eerste letter van een woord is een kleine letter, alle andere deelwoorden beginnen met een hoofdletter. Indien een deelwoord korter is dan 3 tekens wordt het volledige deelwoord in hoofdletters geschreven, behalve als dit deelwoord het begin is van het volledige woord, dan wordt dit in kleine letter geschreven.


voorbeeld eenVoorbeeld abVoorbeeld voorbeeldAB

Een kort overzicht van alle elementen in C#, en hun naamgeving richtlijnen. Namespace Class Interface Enum Structure Field Public field Read-only static field (const) Method Property Indexer Parameter Variable

Pascal Pascal Pascal Pascal Pascal camel Pascal Pascal Pascal Pascal Pascal camel camel

Interfaces worden voorafgegaan door de hoofdletter ‘I’. interface ITest {}

Variabelen op klasse niveau worden voorafgegaan door een underscore ‘_’. class Test { private string _test; }

Structuur Casting Gebruik waar mogelijk het ‘as’ keyword om te casten, dit is performanter en gaat geen exceptions genereren (dit werkt natuurlijk alleen maar bij reference types). object foo = “foo”; string bar = foo as string; //string bar = (string)foo;

Events Delegate declaratie in dezelfde file als de EventArgs declaratie, maar buiten de klasse declaratie. namespace Test { public delegate void TestEventHandler (object sender, TestEventArgs e); class TestEventArgs : EventArgs { } }


Multi-threading Maak gebruik van een intern object om een lock aan te vragen. namespace Test { class TestEventArgs : EventArgs { private object _lock = new object (); void TestMethod () { lock {_lock} {/* .../*} } } }

Using Maak gebruik van using blokken om objecten ‘netjes’ te disposen. using (object x = MaakEenHeelGrootObject ()) { // ... }

Documentatie Alle publieke elementen worden voorzien van xml commentaar. /// <summary> /// dit is commentaar /// public void TestMethod () {}

Interne, protected en private elementen worden optioneel voorzien van xml commentaar. (Eventueel wordt er een gewoon commentaar blok gebruikt om de functie uit te leggen). Markering van code. //TODO: dit is een onderdeel dat nog geïmplementeerd moet worden //FIXME: met dit onderdeel is er iets mis + een korte beschrijving van wat er mis gaat //NOTE: een kleine opmerking

Logging Framework Hierop aansluitend is het de moeite waard om te vermelden dat we gebruik maken van Log4Net.


Assembly Generator Waarom dynamische code Een van de vereisten die bij het ontwerpen van Sheridan naar voor kwam, is het dynamisch aanmaken van .NET assemblies. Dit omdat we onze benchmarks dynamisch gaan compileren waardoor we deze tot in het uiterste kunnen optimaliseren. Na een ruime onderzoekstijd zijn we op de proppen gekomen met 4 verschillende technieken, namelijk de standaard .NET methodes System.Reflection.Emit en System.CodeDom als ook enkele OpenSource varianten, namelijk Refly en Mono.Cecil. Al deze technieken schieten echter te kort op meerdere gebieden, waardoor ze niet bruikbaar zijn voor Sheridan. Hieronder kan je een kort overzicht vinden van de verschillende technieken, geïllustreerd aan de hand van het volgende voorbeeld: Dynamisch code genereren C# for (int i = 0; i < 1000000; i++) {}


Reflection.Emit Dit is een methode die gebruik maakt van de standaard namespaces System.Reflection en System.Reflection.Emit om dynamisch code te genereren. Voorbeeld IL ILGenerator generator = methodBuilder.GetILGenerator (); generator.DeclareLocal (typeof (Int32)); generator.DeclareLocal (typeof (Int32)); Label labelStart = generator.DefineLabel (); Label labelExit = generator.DefineLabel (); generator.Emit (OpCodes.Ldc_I4_0); generator.Emit (OpCodes.Stloc_0); generator.Emit (OpCodes.Ldc_I4, 1000000); generator.Emit (OpCodes.Stloc_1); generator.MarkLabel (labelStart); generator.Emit (OpCodes.Ldloc_0); generator.Emit (OpCodes.Ldloc_1); generator.Emit (OpCodes.Bge, labelExit); generator.Emit generator.Emit generator.Emit generator.Emit generator.Emit

(OpCodes.Ldc_I4_1); (OpCodes.Ldloc_0); (OpCodes.Add); (OpCodes.Stloc_0); (OpCodes.Br, labelStart);

generator.MarkLabel (labelExit); generator.Emit (OpCodes.Ret);

Voordelen • IL code is de absolute basis van het .NET platform, Reflection.Emit heeft dus volledige ondersteuning voor alle features van het .NET platform •

laat enorme optimalisatie toe

Nadelen onvoorstelbaar complex, een eenvoudige for lus bestaat al uit enkele tientallen statements Conclusie Als gevolg van deze complexiteit is het voor ons niet de beste oplossing.


CodeDom Dit is een methode die gebruik maakt van de System.CodeDom namespace. CodeDom is een object georiënteerde voorstelling van code structuren in het .NET platform. Voorbeeld CodeDom CodeVariableDeclarationStatement counter = new CodeVariableDeclarationStatement (typeof (int), "i", new CodePrimitiveExpression (0)); CodeIterationStatement iter = new CodeIterationStatement ( new CodeAssignStatement ( new CodeVariableReferenceExpression ("i"), new CodePrimitiveExpression (0) ), new CodeBinaryOperatorExpression ( new CodeVariableReferenceExpression ("i"), CodeBinaryOperatorType.LessThanOrEqual, new CodePrimitiveExpression (1000000) ), new CodeAssignStatement ( new CodeVariableReferenceExpression ("i"), new CodeBinaryOperatorExpression ( new CodeVariableReferenceExpression ("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression (1) ) ), new CodeStatement[] { } );

Voordelen • omdat er gewerkt wordt met een programmeermodel die vele overeenkomsten heeft met gewone zelfgeschreven code werkt het relatief eenvoudig •

CodeDom wordt gecompileerd met behulp van bestaande C#, VB.Net, … compilers en kan dus de interne optimalisaties hiervan ten volle benutten

Nadelen • hoewel de syntax relatief eenvoudig is, is het geheel nog altijd veel te complex om toe te passen op grote stukken dynamische code •

CodeDom ondersteunt niet alle mogelijkheden van het .NET platform

Overzicht ontbrekende onderdelen CodeDom • CodeCompileUnit heeft geen ondersteuning voor using directives •

ondersteuning voor using aliassen (using A = B.C.D.E.F;)

•

variabelen gedeclareerd in een lijst (int i, j, k, l;)

•

Jagged arrays ([][])


•

params keyword (void Test (params string[] test))

•

unsafe code, zowel de unsafe modifier, als pointers en de sizeof functie ontbreken

•

volatile modifier

•

expliciete interface implementatie (void IInterface.EenMethode ())

•

custom events (add en remove keywords ontbreken)

•

Operator overloading

•

Destructors

•

unary expressies (xor)

•

pre / postfix expressies (i++, ++i)

•

modifiers voor getters/setters (internal set {;} public get {;})

•

attributen zijn maar ondersteund door een beperkt aantal elementen

•

foreach statement en andere soorten loops (alleen for loop is ondersteund)

•

compound assigment statements (+=, -=, *=, /=, %=, ^=)

•

geen ondersteuning voor compiler specifieke functies (dit is logisch, maar toch een minpunt)

•

C# ‘is’ operator (bool instanceof = x is object;)

•

C# ‘as’ cast operator (SomeClass x = a as SomeClass;)

•

C# ‘lock’ statement (lock(object) {…} , wrapper rond System.Threading.Monitor)

•

CodeDom in het algemeen heeft ook nog andere minpunten die niet zo zeer ontbrekende onderdelen zijn, maar wel veel code vereisen

•

flags attribuut toepassen op enumeraties

•

vaak is het vereist om properties te maken voor bepaalde fields, dit is zeer omslachtig

•

om een CodeDom CompileUnit om te zetten naar een System.Reflection.Assembly instantie is er een hele hoop code nodig

Conclusie Wegens het ontbreken van een aantal belangrijke ondersteuningen is deze manier ook niet aangeraden voor Sheridan.


Refly Refly is een ‘wrapper’ rond CodeDom. Dit wil zeggen dat het intern gebruik maakt van CodeDom en alle voordelen hiervan, maar extern een andere (eenvoudigere) API gebruikt. Voorbeeld Refly VariableDeclarationStatement counter = new VariableDeclarationStatement (new TypeTypeDeclaration (typeof (int)), "i"); Stm.For ( Stm.Snippet ("i = 0"), Expr.Snippet ("i < 1000000"), Stm.Snippet ("i++") ));

Voordelen • zeer compacte en verstaanbare code •

maakt intern gebruik van CodeDom en beschikt dus ook over de compiler optimalisaties

•

OpenSource met toelating voor gebruik in commerciële applicaties

Nadelen • is ontworpen voor .NET 1.1 en heeft totaal geen .NET 2.0 ondersteuning •

maakt intern gebruik van CodeDom, en loopt dus tegen dezelfde limitaties aan als CodeDom

Conclusie Dit is een zeer compacte en eenvoudig te gebruiken manier van werken. Het nadeel van de onvolledige .NET 2.0 ondersteuning valt weg aangezien de broncode beschikbaar is, we hebben dus altijd de mogelijkheid om aanpassingen te doen.


Mono.Cecil Mono.Cecil is gebasseerd op Reflection.Emit en heeft hierdoor ook dezelfde nadelen.


Sheridan.AssemblyGenerator Al dit onderzoek bracht ons tot deze conclusie: indien we een krachtige maar ook gebruiksvriendelijke manier willen om dynamisch assemblies aan te maken, gaan we dit zelf moeten schrijven. Vervolgens hebben we de keuze gemaakt om de code structuren van de C# taal zo goed mogelijk na te bootsen. Dit heeft namelijk meerdere voordelen. Als eerste zorgt het er voor dat programmeurs die bekend zijn met C# en de .NET terminologie bijna direct aan de slag kunnen met deze bibliotheek. Als tweede argument zorgt de C# structuur ervoor dat we onze bibliotheek kunnen bouwen als een laag boven de bestaande C# compiler, waardoor we van de bestaande optimalisaties die hierin aanwezig zijn kunnen genieten. Kort code voorbeeld Assembly myAssembly = new Assembly (“Test”, “0.1.0.0”); Namespace ns = myAssembly.AddNamespace(“MyNS”); Class cls = new Class(“MyClass”); Method m = new Method ("Add", new TypeReferenceExpression ("int"), new Parameter ("x", new TypeReferenceExpression ("int")), new Parameter ("y", new TypeReferenceExpression ("int")) ); m.Body.Add(new ReturnStatement ( new BinaryOperatorExpression ( new VariableReferenceExpression (“x”), BinaryOperator.Add, new VariableReferenceExpression (“y”) ) ) ); ns.Types.Add(cls);

Deze blok code gaat een assembly maken met een klasse “MyClass” in de namespace “MyNS”. Deze klasse heeft vervolgens een methode “Add” met als argument x en y, en als terugkeerwaarde de som van deze 2 variabelen. Qua definiëren van de structuur komt dit ongeveer overeen met CodeDom en Refly, alleen is dit iets eenvoudiger aangezien de C# structuur er duidelijk in te herkennen valt. De grote kracht van de AssemblyGenerator komt pas aan het licht wanneer we deze code daadwerkelijk gaan compileren. CompiledAssembly ca = myAssembly.Compile ();

Via één eenvoudig statement kunnen we de assembly compileren. In de “CompiledAssembly” klassen kan je een lijst van eventuele fouten terug vinden als ook een referentie naar de zonet gecompileerde System.Reflection.Assembly indien het compileren foutloos verliep.


Benchmark Resultaten

Figuur 3 : Benchmark van verschillende dynamische code genereer modellen.

Conclusie De resultaten van Sheridan.AssemblyGenerator, System.CodeDOM en Refly zijn zo goed als hetzelfde, dit omdat ze alle 3 een laag rondom de C# compiler zijn, en dus optimaal de optimalisaties van de C# compiler kunnen benutten. De resultaten van Reflection.Emit vallen sterk tegen, omwille van de complexiteit van MS IL is het moeilijk voor mensen om performante code te schrijven.


Heimdall Mythologie The Watcher, he never sleeps and can see in the dark.

Algemeen Heimdall is een interim tool die ontwikkeld werd door Brecht Kets, om problemen en fouten van de vorige generatie benchmarks ongedaan te maken. Het begrip interim tool duidt aan dat deze tool een tijdelijk karakter heeft. Heimdall werd gebruikt in afwachting van Sheridan, de officiële benchmark tool. Dat is ook te merken aan zijn naam, die slaat op zijn korte ontwikkelingsduur en verwijst naar The Watcher (he never sleeps and can see in the dark).

DbConn DbConn is de tool die ontwikkeld werd in 2004 om MySQL, MS SQL Server en DB2 te benchmarken. Dit is een basis tool die niettegenstaande enkele nadelen, toch goed werk verricht. Deze tool mag dan wel stabiel werken, maar de userinterface zit nog niet in een aparte thread, wat het weergeven van feedback en de huidige status onmogelijk maakt.

Figuur 4 : DBconn 2004

Het is moeilijk om deze broncode te updaten, omdat er niet gedacht werd aan eventuele uitbreidingen. Dit zorgt ervoor dat wanneer je bijvoorbeeld een nieuwe database wil ondersteunen, je je door de ganse code moet wurmen om toevoegingen te schrijven. Maar deze schoonheidsfoutjes zijn niet de reden waarom ik deze tool heb herschreven. Brecht vond namelijk enkele elementaire denken meetfouten terug. Deze worden in de volgende alinea’s besproken.


Figuur 5 : source code uit DBconn 2004

Zoals hierboven geïllustreerd is, wordt in de tijdsberekening geen rekening gehouden met de tijd die het programma nodig heeft om threads te starten en objecten aan te maken. Na onderzoek van deze meetfout bleek dat deze vooral foutieve waarden aangaf tijdens de simulatie van een laag aantal gebruikers. De simulatie van een hoger aantal gebruikers blijkt realistischere resultaten weer te geven. Zoals u ook kan zien in bovenstaande screenshot wordt er in de tijdsberekening gebruikt gemaakt van Now(), waarop berekeningen worden toegepast. Dit is ook niet de optimale manier. Je kan beter gebruik maken van een TimeStamp. Deze kun je zo vergelijken om de tijd in milliseconden te bekomen en zo worden er minder onnodige bewerkingen gedaan. Dit is tevens meer accuraat en niet gevoelig aan rekenfouten.

Figuur 6 : Random queries in DBBench 2004


Het uitvoeren van de ‘random’-queries gebeurt in een switch case, die totaal geen dynamisme heeft. In Heimdall daarentegen wordt er gebruik gemaakt van delegates. In Heimdall staan de queries ook nog in de code zelf en niet in een externe xml-file. De reden hiervoor is dat je daar een scripttaal moet voor ontwikkelen. Dit zou echter te veel tijd in beslag nemen. Waarom biedt de DbBench oplossing geen dynamisme? Ten eerste omdat je de functies via de code zelf moet ingeven, dus toekomstige aanpassingen zijn al moeilijk. Daar aangezien alles hard-coded is, heeft de gebruiker geen controle over randomizing, enz.

Figuur 7 : Geen uitbreidbaarheid in DBconn 2004

Het uitvoeren van een select statement gebeurt via een if-statement. Dit komt zeker niet ten goede van de uitbreidbaarheid. Er wordt ook gebruik gemaakt van datatables, wat niet de meest optimale manier is. In Heimdall wordt er (eveneens wegens de beperking in tijd) ook niet naar deze opties gekeken. In normale omstandigheden zou men werken met een datareader, maar ik koos voor een datatable met weliswaar enkele optimalisaties. Voordat ik de fillmethode oproep, zorg ik ervoor dat de datatable relaties en andere tijdsconsumerende dingen niet nakijkt. Volgend voorbeeld illustreert dit :

Ook wordt in Heimdall gewerkt met een ConnectionManager klasse, die elke connectionwrapper kan aanspreken. Dit bevordert de uitbreidbaarheid ten volle. Naast de fouten in tijdsberekening was een andere flagrante fout, dat wanneer men een query uitvoerde men telkens een nieuwe connectie met de database opende en deze achteraf terug sloot. Dit is niet enkel onrealistisch, maar zorgt ook voor fouten in een geoptimaliseerd programma, wanneer men dit probeert met MySQL. De reden hiervoor is: om via een client naar een MySQL server te connecteren, wordt er gebruik gemaakt van


logische poorten (socket op poort 3306 bv.). Er zijn slechts een beperkt aantal simultane connecties (sessies) per poort toegelaten. Na het sluiten van de connectie duurt het nog ongeveer 3 minuten vooraleer deze poort vrijgegeven wordt, zoals bepaald door de TCP-standaard. In Windows kan deze time-out aangepast worden in het register (http://support.microsoft.com/kb/Q149532). Als er geen vrije poorten meer zijn onder Windows, dan weigert Windows de aanvraag tot connectie. Indien er onder Linux geen vrije poorten meer zijn, kijkt hij welke poorten al inactief zijn en gebruikt hij deze. Deze fout komt dus enkel in Windows voor.


BenchDB 2005 Deze tool werd in 2005 ontwikkeld om de tekortkomingen van DbConn tegemoet te komen. Dit is jammer genoeg niet op alle vlakken gelukt en bracht tevens enkele bijkomende problemen met zich mee.

Figuur 8 : Screenshot DB Bench 2005

Figuur 9 : Screenshot DB Bench 2005


In deze tool is feedback wel mogelijk, omdat de user-interface in een andere thread zit. Er is dus wel degelijk enige vooruitgang geboekt, want de code is een pak dynamischer opgebouwd. Toch is deze nog altijd moeilijk om aan te passen. Men heeft toen duidelijk veel werk gestoken in de weergave van de huidige status, maar dit had als consequentie dat de tool onnodig veel resources verbruikt en aldus geen betrouwbare resultaten meer oplevert. Wat ook kan bijdragen aan deze wispelturige resultaten, is het gebruik van de .Net threadpool. Deze is namelijk niet geschikt voor dit type applicatie. Waar Heimdall 5% CPU verbruikt, verteert DbBench 2005 50 tot 60 percent. Tevens, wanneer men twee tests na elkaar uitvoert, kunnen de resultaten met 100 queries variëren. Dit zijn de redenen waarom deze tool nooit gebruikt werd. We zijn onmiddellijk overgestapt van DbConn naar onze interim-client Heimdall.


Heimdall Onze interim-client Heimdall, is dus ontworpen om aan bovenstaande problemen een tijdelijke oplossing te bieden.

Figuur 10 : Screenshot Heimdall

Features •

Uitgebreide error logging.

•

Visuele weergave van de huidige status tijdens een benchmark.

•

Database belasten op verschillende sterkte niveaus.

•

Ondersteuning voor DB2, MySQL, MS SQL Server, Sybase en PostgreSql.

•

Mogelijkheid om connectie te sluiten na elke request.

•

Mogelijkheid om connection-pooling te gebruiken.


Parameters Concurrency De concurrency is het aantal users dat moet gesimuleerd worden. Hierbij worden een aantal threads gestart, die simultaan requests uitvoeren. De verschillende waarden moeten met de hand ingevoerd worden, gescheiden door een puntkomma. Requests Dit staat voor het aantal requests dat moet worden uitgevoerd. Een request bestaat uit meerdere sql-statements, waarvan de parameters random zijn. Ook deze waarde wordt door de gebruiker ingevoerd. Precision De precision is het aantal keren dat een test moet uitgevoerd worden op een specifieke concurrency. Dit is nodig om realistische resultaten te garanderen.

Test opzetten met MySQL Voorwaarden client Op de client-machine is de enige voorwaarde dat het .Net framework 2.0 geïnstalleerd is. Dit is nodig voor een correcte werking van Heimdall. Voorwaarden server Op de server dient MySQL server geïnstalleerd zijn. Dit mag zowel versie 4.0, 4.1 of 5.0 zijn. Je kan controleren of MySQL geïnstalleerd is door volgende regel in een terminal in te tikken: # /etc/init.d/mysql start

Indien MySQL opstart is het programma duidelijk geïnstalleerd. My.cnf restoren Kopieer de bijgeleverde my.cnf naar /var/lib/mysql/my.cnf (vergeet de extensie niet te veranderen). # cp /mnt/cdrom/config/my.conf /var/lib/mysql/my.cnf

Verwijder vervolgens alle logfiles en datafiles uit de datadir. # rm /var/lib/mysql/ib*

Herstart MySQL.


Indien alles goed verliep, zal je onmiddellijk de feedback ‘done’ te zien krijgen. Maar toch moet je eventjes wachten, omdat de server op dat moment nog steeds bezig zal zijn met het instellen van de ibdata1-file op 2000 MB. Waarden Controleren Start de MySQL client via volgend commando: # mysql

(indien met wachtwoord: # mysql –p) Indien alles goed verliep, zal InnoDB beschikbaar zijn. mysql> show variables like ‘%innodb%’;

Database terugplaatsen Via sql Geef volgende waarden in via de MySQL client: mysql> create database benchdb; mysql> use benchdb; mysql> source /mnt/cdrom/backup/benchdb_backup.sql;

Na dit laatste commando zal de database zichzelf restoren. Dit kan je zien aan volgend scherm:

Figuur 11 : Restoren van MySql database

Indien het systeem over SCSI- of SAS-schijven beschikt, zal deze actie ongeveer 15 à 20 minuten in beslag nemen. Als deze niet aanwezig zijn, duurt het 2 à 6 uur. Via Datafiles Voor deze methode dienen we MySQL Server te stoppen en de originele datadirectory te verwijderen.


# /etc/init.d/mysql stop # rm –r /var/lib/mysql

Vervolgens kunnen we onze datafiles terugzetten. # tar zxvf /mnt/cdrom/data/mysql-data-4.0.x.tar.gz -C /var/lib/mysql # mv /var/lib/mysql-data-4.0.x /var/lib/mysql

Tenslotte moeten we de eigenaar terug goed instellen. # chown –R mysql:mysql /var/lib/mysql

Externe Toegang instellen Men kan externe toegang toelaten, via de volgende commando’s: mysql> grant all privileges on *.* to root@’%’ identified by ‘password’; mysql> flush privileges;

Het ‘password’ moet je vervangen door het gewenste paswoord. Indien u geen paswoord wenst te gebruiken, kan u ‘identified by password’ weglaten. In de globale config-file (/etc/mysql/my.cnf of /etc /my.cnf ) moet de volgende waarde nog aangepast worden: bind-address = 0.0.0.0 Testen Leg een gigabit-verbinding tussen de client en de server, stel de IP’s in en druk op ‘Bench’.


Test opzetten met PostgreSql Voorwaarden client Op de client-machine is de enige voorwaarde dat het .net Framework 2.0 geïnstalleerd is. Dit is nodig voor een correcte werking van Heimdall. Voorwaarden server Op de server moet PostgreSql geïnstalleerd zijn. Dit voorbeeld is gebaseerd op Suse Linux Enterprise Server 9. Controleren of het geïnstalleerd is via: # find / | grep postgres

Figuur 12 : Controle installatie PostGreSQL

Indien het al geïnstalleerd staat kan je het verwijderen met yast. Installatie De installatie van PostgreSQL moet gebeuren via compilatie van de code. Eerst extracten we de installatiebestanden naar een tijdelijke map, vb. /tmp. De installatiebestanden kunnen gedownload worden van de website www.postgresql.org. # tar jxvf /mnt/cdrom/PostGreSQL-installs/postgresql-8.0.7.tar.bz2 -C /tmp/ # cd /tmp/postgresql-8.0.7

Het commando "Configure" dient om na te gaan of alles aanwezig is om de mogelijkheid te hebben om te compileren. # ./configure


In normale omstandighedens zouden alle compile-tools moeten geïnstalleerd zijn. Indien niet, kun je ze via YaST eventueel installeren. Nadat je de eventuele tools geïnstalleerd hebt mag je zonder problemen het 'configure' commando opnieuw uitvoeren. Indien alles correct verlopen is moet je iets in de aard van onderstaande afbeelding te zien krijgen.

Figuur 13 : Configureren van PostGreSQL

Nu zijn we klaar voor het compilen zelf: # make && make install


Figuur 14 : Compileren van PostGreSQL op Linux machine

Figuur 15 : Verloop compileer actie van PostGreSQL op Linux machine


Nu mag de tijdelijke map eventueel verwijderd worden # cd && rm -r /tmp/postgresql-8.0.7


Postgres gebruiker aanmaken De nodige gebruikers aanmaken kan via volgend commando: # groupadd postgres && useradd -G postgres postgres

Data herstellen Nu kunnen we de data-directory aanmaken waar de juiste database reeds in aanwezig is, en de eigenaar correct instellen: # tar xvf /mnt/cdrom/backup/postgresql_backup.tar -C / # chown -R postgres:postgres /var/lib/postgresql

Er moet ook nog een pid-file verwijderd worden: # rm /var/lib/postgresql/data/postmaster.pid


Kernel-parameters wijzigen Nu dienen we ook ook nog het kernel geheugen (shmmax) aan te passen # echo 4000000000 > /proc/sys/kernel/shmmax

Instellingen wijzigen Nu moeten we overschakelen naar de postgres-user: # su postgres

Eenmaal daar dienen 2 omgevings-variabelen ingesteld te worden: PGDATA, de datadirectory van PostGreSQL en het PATH, om sneller aan de noodzakelijke 'postmaster' & 'pg_ctl' te kunnen (in /usr/local/pgsql/bin) # export PGDATA=/var/lib/postgresql/data # export PATH=$PATH:/usr/local/pgsql/bin

Nu nog het ip instellen van de client die de server zal testen, dit pas je aan in /var/lib/postgresql/data/pg_hba.conf # vim /var/lib/postgresql/data/pg_hba.conf


Helemaal onder zul je onder "#IPv4 local connections" al enkele dingen zien toegelaten staan, voeg daaronder (of pas de huidige aan) naar het juist client-ip adres:


Gebruikers aanmaken We dienen ook nog een root gebruiker aan te maken die kan verbinden met PostGreSQL, dit doen we als postgresql-user: # createuser -P root

Het passwoord zal 2x gevraagd worden, en op de overige 2 vragen mag je 'y' antwoorden.

Server starten Nu kunnen we de server starten onder de postgresql gebruiker met het volgende commando: # postmaster &

Willen we hem stoppen, doen we dit terug onder de postgresql-user: # pg_ctl stop

Testen Leg een gigabit-verbinding tussen de client en de server, stel de IP’s in en druk op ‘Bench’.


Sheridan Algemeen Een nieuw softwareproject plaatst systeembeheerders en softwareontwikkelaars voor verschillende problemen: is de huidige server krachtig genoeg om de nieuwe database software intensief te laten gebruiken? Indien een nieuwe server aangeschaft wordt, in welke hardwarecomponenten moet er extra geïnvesteerd worden om bottlenecks te voorkomen? Wat als er in de toekomst veel meer of intensiever gebruik gemaakt wordt van deze applicatie? De softwareontwikkelaar kent een gelijkaardig probleem. Hoe goed schaalt de ontwikkelde database applicatie op de aanwezige servers van de klant? Leveren de aangeprezen optimalisaties in de nieuwste versie werkelijk betere prestaties bij intensief gebruik? Sheridan lost dit op via : •

zeer flexibele tool die test met bedrijfseigen applicaties

•

geeft idee van toekomstige schaling

•

aanwezigheid van zowel client als server monitoring

•

snel en gebruiksvriendelijk

•

benchmark platform voor alle server applicaties

Momenteel zijn wij door de intercommunale Leiedal bekroond voor het innovatief karakter van onze software.

Voor wie ? Systeem Administrators •

zal de huidige server de nieuwe database applicatie aankunnen ?

•

toekomstige schaling ?

•

waar ligt de bottleneck ?

Softwareontwikkelaars •

bewijzen dat de software goed schaalt op servers klant

•

bewijzen dat nieuwere versies voordeel opbrengen


Hoe te gebruiken ? In deze sectie zal uitgelegd worden hoe je Sheridan moet gebruiken. Nadien wordt er dieper op elk stuk apart ingegaan. Algemeen Hieronder kan u een handleiding vinden van hoe te benchmarken met Sheridan. In dit voorbeeld hebben we een testcase van het Ieperse bedrijf D&N uitgewerkt. Solution Allereerst moet je beginnen met een nieuwe solution aan te maken. Een solution is een logische groepering van testen die u op een bepaalde software of server wilt uitvoeren. Een nieuwe solution aanmaken kan via File – New – Solution. Vervolgens moet u een naam en de locatie opgeven.

Figuur 16 : Nieuwe Solution aanmaken

Project Aan een Solution kunt u meerdere projecten toevoegen. Een project is een type benchmark die u wenst uit te voeren. Een nieuw project aanmaken kan je via File – New – Project, of via rechter muisklik op het project en ‘Add Project’. Volgend dialoogvenster komt tevoorschijn.

Figuur 17 : Nieuw project aanmaken


Kies uw type benchmark, en geef een naam en locatie op. Druk op Ok. Momenteel is enkel een Balanced Concurrency Benchmark ondersteund, maar via addins kunnen er ook andere types benchmarks toegevoegd worden. Een voorbeeld is een response time benchmark. Connection Aan een database-benchmark is het evident dat je een connectie naar een database kan toevoegen. Een project kan meerdere connecties bevatten. Een connectie toevoegen, doe je via rechter muisklik op ‘Connections’ in uw Solution Explorer.

Figuur 18 : Een database provider kiezen

Kies eerst uw type database. DB2, MySQL, Oracle, PostgreSql, MS SQL Server en Sybase worden momenteel ondersteund.


Figuur 19 : Connectie gegevens instellen

Geef uw instellingen in en druk op Next, gevolgd door Finish.


Structure Vervolgens kan u een structuur aan uw project toevoegen. Een voorbeeld van een structuur kan een log-file van uw database zijn. Het is mogelijk om meerdere logs aan een project toe te voegen. Het kan vb. perfect zijn dat u eerst een read-only test wil doen en daarna pas een OLTP-test. Een nieuwe structuur toevoegen kan u via File – New – Structure of via rechter muisklik op het project gevolgd door ‘Add Item’.

Figuur 20 : Nieuw item toevoegen

Geef het type structuur op gevolgd door de naam. In dit geval kiezen we voor een ‘Query Structure’, omdat we een log-file wensen in te lezen. Import Sql statements Een query structure maakt het mogelijk om sql-statements automatisch in te lezen via log-files. Dit kan u via rechter muisklik op uw query structure, gevolgd door ‘Import Sql Statements’.

Figuur 21 : Importeren van eigen log file


Selecteer het sql-dialect waaruit uw log-file bestaat, gevolgd door uw import methode. Xml en plain text file worden standaard ondersteund. Als u xml selecteerd kan u via X-Path de nodes opgeven waarin de queries zich bevinden. Via ‘Plain Text File’ kan u de seperator opgeven. Indien u een of ander exotisch formaat hebt, kunt u zelf een C#-script schrijven om uw queries uit te lezen. In dit voorbeeld maken we gebruik van ‘Plain Text File’.

Figuur 22 : Importatie via Plain Text

Geef de bestandslocatie op gevolgd door de Separator en druk op Next. Druk vervolgens op Ok. U krijgt nu volgend venster te zien:


Figuur 23 : Preview log file

Via dit venster kan u de structuur van uw sql-statements definiëren. Om een query afhankelijk te maken van een andere, druk op het pijltje naar rechts, om een query niet meer afhankelijk te maken van een ander druk op het pijltje naar links. In dit voorbeeld is de 2de query afhankelijk van de eerste. Dit wil zeggen dat voor elke rij de eerste query teruggeeft, de 2de query uitgevoerd wordt. Indien de structuur naar uw wensen is, druk op ok.


Manuele aanpassingen U kunt nu nog manuele aanpassingen te doen per query-group. Dubbelklik op een query en een nieuw tabblad zal verschijnen. In het tabblad syntax kunt u de structuur van uw sql-statements aanpassen. Dit via Queryscript.

Figuur 24 : Aanpassing via Queryscript

Een volledige handleiding over Queryscript kan u in de help terug vinden. Via het tabblad Queries is het mogelijk manuele aanpassingen te maken aan de queries, evenals parameters in te stellen.

Figuur 25 : Randomizing instellen

Indien een query parameters heeft kunt u deze ook via dit venster instellen, net zoals randomizing opties. Om alle waarden van insert statements beschikbaar te maken voor volgende selects kan je gebruik maken van de object pool.


Figuur 26 : De Object Pool

De object pool maakt het mogelijk om een bepaald veld na een insert statement op te slaan. Vb. als je een rij in een database toevoegt, dan kan het zijn dat later in de benchmark een select wil doen op dat id. Het is ook mogelijk een treshold in te stellen. Als je een object pool toevoegd met een treshold van 30, wil dit zeggen dat per 1000 inserts 30 waarden zullen opgeslagen worden in de object pool. Performance Monitor U kan ook een performance monitor aan uw project toevoegen. Een performance monitor maakt het mogelijk de client of server zijn prestaties te volgen. U kunt een performance monitor toevoegen op dezelfde manier als een structure. U kiest enkel als type performance monitor. Benchmark Om de benchmark te starten, klikt u op het menu Benchmark gevolgd door uw type benchmark.

Figuur 27 : Kies type benchmark


Hier krijgt u de mogelijkheid uw project, benchmark en connectie te kiezen. Druk vervolgens op Ok om het benchmark-venster te voorschijn te brengen. Nu krijgt u feedback of uw queries goed gedefinieerd zijn.

Figuur 28 : Compile info

Als alles goed verlopen is krijgt u volgend venster te zien:


Figuur 29 : Een Sheridan Benchmark

Nadat u op de start knop gedrukt hebt, start de benchmark en worden de resultaten realtime weergegeven. Connection Manager De connection manager maakt het mogelijk de structuur van uw database te bekijken, samen met de primary keys, stored procedures en views. Relaties zijn eveneens te bekijken. De connection manager kan je openen via View – Connection Manager. Query editor Via de query editor kan u uw sql-statements testen. Klik op Tools – Query editor.


Figuur 30 : Query Editor

Addin Manager Via de addin manager kan u modules in- of uitschakelen. Indien u een module uitschakelt waar een andere module gebruik moet van maken, wordt deze automatisch ook uitgeschakeld.

Figuur 31 : Screenshot addin manager


Log viewer Indien u problemen ondervind met Sheridan kan u meer info vinden via de logbestanden. Deze kan u raadplegen via Tools – Log Viewer. Indien dit u geen hulp biedt kan u altijd een bug melden aan de ontwikkelaars. Dit kan via Tools – Bug Report.

Figuur 32 : Logviewer Sheridan

Structuur Sheridan kan in verschillende elementen verdeeld worden. Deze elementen zullen achteraf uitgebreid uitgelegd worden.

Figuur 33 : Structurele voorstelling van Sheridan


Sheridan.Core Algemeen Sheridan Core is een aangepaste versie van de SharpDevelop (http://icsharpcode.net/OpenSource/SD/Default.aspx) Core module. Auteurs Copyright 2002-2006 by AlphaSierraPapa, Christoph Wille Vordernberger Strasse 27/8 A-8700 Leoben Austria [email protected] Licentie LGPL http://www.gnu.org/licenses/lgpl.html Introductie Sheridan is opgebouwd vanuit het standpunt dat uitbreidbaarheid zeer eenvoudig moet zijn, daarom maken we gebruik van het Addin Systeem ontwikkeld door SharpDevelop, een zeer robuuste manier om uitbreidbaarheid toe te voegen aan applicaties. Het Sheridan.Addin project doet niet meer dan gebruik maken van de addin functionaliteit van Sheridan.Core. Via Sheridan.Addin kunnen addins in- en uitgeschakeld worden. Indien een addin afhankelijk is van een uitgeschakelde addin wordt deze automatisch ook uitgeschakeld. Essentiële addins kunnen niet worden uitgeschakeld.



Addin Bestanden Elk Addin bestand is een xml bestand met de extensie “.addin” <Manifest>

AddIn coreAddin Het coreAddin attribuut wordt gebruikt om aan te duiden dat een module absoluut noodzakelijk is voor de correcte werking van het programma. Indien deze eigenschap op “false” staat gaat de module nog altijd ingeladen worden, maar beschikt de gebruiker om de functionaliteit uit te schakelen via de AddIn manager. Manifest Het manifest element is verplicht in elk AddIn bestand en is verantwoordelijk voor het identificeren van de huidige AddIn. Identity Exact 1 element van dit type moet toegevoegd worden voor het correct benoemen van een AddIn. De “name” eigenschap is verantwoordelijk voor de interne naamgeving van de module en de “version” eigenschap gaat de versie van de module aanduiden. Name Toegelaten waarden: a-z A-Z 0-9 . Version In het formaat Major.Minor.Build.Revision Dependency Een dependency element is optioneel, en kan een oneindig aantal keren voorkomen in het manifest element. Addin De interne naam van de AddIn die vereist is voor de correcte werking van deze module.


Version Een bepaalde versie of een range van versies die compatibel zijn met de huidige versie van deze AddIn. De “version” eigenschap is optioneel. Bijvoorbeeld “0.1.0.0-0.2.3.6” of “1.3.0.0” Versie “2.0” komt overeen met alle versies die beginnen met 2.0 (2.0.*.*) Runtime Het runtime element is verplicht in elk AddIn bestand en is verantwoordelijk voor het koppelen van .NET assemblies aan de AddIn bestanden. Import Dit element zorgt ervoor dat een bepaalde .NET assembly wordt ingeladen wanneer deze AddIn wordt aangesproken Assembly Een relatieve of absolute padverwijzing naar een .NET assembly (.dll of .exe) Standaard Doozers Class Een class doozer wordt gebruikt om via reflection instanties van bepaalde objecten aan te maken.

class De volledige klasse naam van een object. Dit attribuut is vereist. Opgelet: om een nieuw object aan te maken via reflection is het vereist dat de klasse een publieke constructor heeft zonder parameters. terugkeerwaarde Een nieuwe instantie van het gespecificeerde object. Standaard Condities Compare Deze conditie gaat 2 strings hoofdletter ongevoelig vergelijken met elkaar. De strings gaan eerst verwerkt worden door de StringParser service, dit zorgt ervaar dat deze conditie in staat is om bepaalde configuratie waardes te vergelijken met elkaar. Bijvoorbeeld: …


string De eerste string equals De tweede string waarmee vergeleken gaat worden comparisonType Een veld uit de “System.StringComparison” enumeratie. Dit attribuut is optioneel en staat standaard ingesteld op “InvariantCultureIgnoreCase”.


Sheridan.Base Solutions Een solution is een bestandsformaat dat alle nodige informatie over diverse projecten kan opslaan. Aangezien het mogelijk is om via plugins extra benchmark types toe te voegen, moet de solution ook in staat zijn om de nodige informatie hierover op te slaan. Daarom werken we met de volgende structuur:

Solution + Project + ProjectItem

Elke solution kan een lijst van projecten bevatten en elk project kan op zich weer een lijst van project items bevatten. Elk project en projectitem moet ook een load en save methode implementeren. Deze methodes zorgen ervoor dat de solution alle nodige informatie kan opslaan. Ook bestaat er een SolutionService. Deze service is verantwoordelijk voor het laden en sluiten van solutions, als ook het versturen van events indien er iets wijzigt aan de geopende solution. Ten slotte is er ook de RecentSolutionService, deze houdt een overzicht bij van de 10 meest recent geopende solutions. AddinTreeView

Figuur 35 : Solution Explorer

De AddinTreeView is een speciale TreeView die het toelaat om zonder directe toegang nodes toe te voegen in de tree. Dit is een noodzakelijke vereiste die het mogelijk maakt om vanuit plugins nodes toe te voegen.


TreeBuilder De “TreeBuilder” klasse is verantwoordelijk voor het opvullen van een TreeView. Deze klasse gaat bepalen welke TreeNodeBuilder er moet gebruikt worden om een bepaald object te tekenen en gaat dit in goede banen leiden. Een aantal nuttige methodes: void AddNode (object obj); void AddNode (object parent, object child); void UpdateNode (object node); void RemoveNode (object obj);

TreeNodeChain Een “TreeNodeChain” is een object dat voor elke node in de boomstructuur zijn “geschiedenis” gaat bijhouden. Het kan bijvoorbeeld nodig zijn dat een bepaalde node in de boomstructuur informatie nodig heeft van een van zijn bovenliggende nodes. Bijvoorbeeld: + parent + child 1 + child 2

Indien het “child 2” object een bepaalde waarde nodig heeft van het “parent” object, kan het “parent” object in zijn “TreeNodeChain” een bepaalde waarde toevoegen waarna “child 2” deze waarde terug kan uitlezen. Wat zeer belangrijk is, is dat elke node de oorsprong is van zijn eigen “ketting”, een voorbeeld hiervoor + aaa + b + bb + c + cc

Stel de volgende situatie voor: Node “cc” heeft de string “naam” nodig van parent node “c” en node “bb” heeft ook de string “naam” nodig van parent node “b”. Het wordt al snel duidelijk dat beiden namen verschillend zijn. Om dit op te lossen gaat bij elke vertakking in de boomstructuur een nieuwe ketting aangemaakt worden die informatie gaat bijhouden. Node “cc” heeft dus toegang tot de objecten die toegevoegd zijn door de “c” en “aaa” node, terwijl node “bb” toegang heeft tot de objecten die door node “b” en “aaa” zijn toegevoegd. object this[object key] { get; set; }


TreeNodeContext Het “TreeNodeContext” object wordt gebruikt om de huidige positie in een TreeView aan de duiden. Deze klasse heeft het object ter beschikking dat moet getekent worden door de TreeNodeBuilder en heeft ook de TreeNodeChain van dit object en de TreeBuilder van de TreeView ter beschikking. TreeNodeBuilder Een tree node builder is een klasse die verantwoordelijk is voor het grafisch voorstellen van een object in een boomstructuur. Deze klasse moet altijd de interface “ITreeNodeBuilder” implementeren (of voor gebruiksgemak de abstracte klasse “AbstractTreeNodeBuilder”).

bool void void bool

CanBuildObject (Type objectType); BuildNode (TreeNodeContext context, out string text, out string icon); BuildChildNodes (TreeNodeContext context); HasChildNodes (TreeNodeContext context);

De bovenstaande methodes worden gebruikt om objecten te tekenen. De “CanBuildObject” methode gaat aan de hand van het object type bepalen of deze TreeNodeBuilder geschikt is voor het tekenen van een object. Deze methode maakt het mogelijk om alleen specifieke types af te handelen of alle subklassen van een bepaald type (door middel van de methode IsSubclassOf van het “objectType” object). De “BuildNode” methode wordt gebruikt om met behulp van de huidige TreeNodeContext de tekst en het icoontje van de TreeNode in te stellen. Het object dat moet voorgesteld worden kan uit de TreeNodeContext klasse bemachtigd worden. Aan da hand van dit object kunnen hierna de “text” en “icon” parameters opgevuld worden. Opmerking: De “icon” parameter moet de naam van een icoon bevatten, deze naam komt overeen met de naam die door de ResourceService gebruikt wordt. Een bijkomende vereiste is dat alle icoontjes die ooit gebruikt kunnen worden door de functie string[] GetRequiredIcons ();

moeten geregistreerd worden. Dit is noodzakelijk omdat een TreeView op voorhand alle icoontjes moet kunnen toevoegen aan een ImageList. De “BuildChildNodes” methode is optioneel, deze methode kan gebruikt worden indien een node child nodes wenst toe te voegen. Dit is mogelijk door in de methode de AddNode (parent, child) methode van de TreeBuilder aan te roepen. Als laatste methode is er “HasChildNodes”, indien deze methode “false” teruggeeft gaat de BuildChildNodes methode nooit aangeroepen worden en gaat er tijd bespaard worden omdat er niet geprobeerd worden nodes te builden.


Tot slot bestaat er ook de mogelijkheid om multi-threaded te werken. Indien het bouwen van een node of child nodes lang duurt (bijvoorbeeld, er moet een database connectie gemaakt worden tijdens het bouwen van child nodes) kan er door middel van het ThreadDispatch attribuut aangeduid worden dat de TreeNodeBuilder een multi-threaded aanroep wenst. Dit attribuut zorgt er ook automatisch voor dat het resultaat automatisch terug naar de Gui thread wordt dispatched, waardoor er geen multi-threading issues kunnen onstaan. TreeNode Context Menu string ContextMenuAddinPath { get; }

Deze string verwijst naar het addin extention point waar de rechtsklik menu van de TreeNode gedefinieerd staat. Indien er geen rechtsklik menu nodig is mag deze property leeg blijven. Hernoemen van de TreeNode bool CanRename { get; } bool Rename (TreeNodeContext context, string name);

Ten eerste gaat de CanRename property aangeven of de node in de eerste plaats hernoemt kan worden. Zo is het bijvoorbeeld mogelijk dat de tekst van een node nooit veranderd. Indien deze methode “true” terugkeert gaat de Rename methode aangeroepen worden met als attribuut de naam die in de Gui is ingevuld. Deze methode kan dan eventueel valideren of de voorgestelde naam correct is. Dubbelklik Event void Activate (TreeNodeContext context);

Wanneer er gedubbelklikt wordt op een node gaat de Activate methode aangeroepen worden. TreeNodeBuilders registreren Ten slotte moet de AddinTreeView weten welke TreeNodeBuilder klassen gebruikt kunnen worden om de objecten te bouwen in de TreeView.

InitializeAddinTree ("/Sheridan/Demo/AddinTreeView");


Concreet Voorbeeld Stel, je hebt een formulier met een AddinTreeView. In deze boom wil je objecten van het type “Land” toevoegen en elk Land object gaat een lijst van “Gemeente” objecten ophalen wanneer het Land object wordt opengeklapt.

AddinTreeView tree = new AddinTreeView (); tree.InitializeAddinTree ("/Sheridan/Demo/AddinTreeView");

Object klassen class Land { string Naam { get; } List Gemeentes { get; } }

class Gemeente { string Naam { get; } string Postcode { get; } }

TreeBuilder klassen

class LandTreeBuilder : AbstractTreeNodeBuilder { public override bool CanBuildObject (Type objectType) { return objectType == typeof (Land); } public override void BuildNode (TreeNodeContext context, out string text, out string icon) { Land land = context.Object as Land; text = land.Naam; icon = ""; } [ThreadDispatch] public override void BuildChildNodes (TreeNodeContext context) { Land land = context.Object as Land; //Haal de gemeentes op uit de database, aangezien dit enkele seconden kan //duren werken we multi-threaded, vandaar het ThreadDispatch attribuut foreach (Gemeente g in land.Gemeentes) context.TreeBuilder.AddNode (land, g); } }


class GemeenteTreeBuilder : AbstractTreeNodeBuilder { public override bool CanBuildObject (Type objectType) { return objectType == typeof (Gemeente); } public override void BuildNode (TreeNodeContext context, out string text, out string icon) { Gemeente g = context.Object as Gemeente; text = g.Naam; icon = ""; } }

Objecten tonen in tree Land land = new Land ("België"); tree.AddNode (land);

Toevoegen in addin <Path name = "/Sheridan/Demo/AddinTreeView">


Code Editor De Code Editor control is een component dat gebaseerd is op de SharpDevelop code editor. Deze editor is in staat om de syntax van bepaalde documenten te kleuren, zodat deze beter leesbaar is. Verder bestaat er ook de mogelijkheid om error markings toe te voegen, dit zorgt ervoor dat er een visuele voorstelling mogelijk is voor eventuele syntactische fouten in de code.

Gui Dispatcher De Gui dispatcher klasse is een hulpmiddel voor het werken in een multithreaded omgeving. Standaard bestaat er voor elk System.Windows.Forms.Control object een Invoke methode, die een functie kan uitvoeren op de Gui thread. Deze methode heeft echter een aantal beperkingen. Zo gaat de Invoke methode enkel werken indien de Control een window handle heeft, wat enkel gebeurt indien de control daadwerkelijk op het scherm getekend is. Indien je dus in een multi-threaded omgeving de gui wilt aanpassen nadat de Controls zijn geïnitialiseerd, maar voordat ze op het scherm getekend zijn, heb je dus problemen. De oplossing hiervoor is de GuiDispatcher klasse, deze klasse is in staat function calls op bepaalde controls uit te stellen totdat deze controls daadwerkelijk getekend worden. Validating Control Group De Validating Control Group is een groepering van klassen die het valideren van invoerformuleren aanzienlijk vereenvoudigd. Deze manier van werken is veel krachtiger dan de standaard .Net Error provider, aangezien de validating control group groeperingen van controls toe laat. Zo is het bijvoorbeeld mogelijk om een ComboBox met 3 tekstvakken te linken aan een OK knop. Deze knop gaat dat enkel actief zijn wanneer alle 4 de velden correct gevalideerd worden.


Voor tekst-validatie bestaan er verschillende mogelijkheden. Zo kan elk tekstvak gevalideerd worden op de gehele inhoud of op elke “keypress” aan de hand van verschillende regels. Een meer specifiek voorbeeld is de Numerieke tekst validatie regel, deze regel zorgt ervoor dat alleen de tekst “0123456789” aanvaard wordt, en eventueel ook een “.”. Indien je een zeer specifiek soort validatie wilt is het ook mogelijk om zelf een validatie regel toe te voegen.


Sheridan.Gui Algemeen Sheridan.GUI is een assembly waar je alle basis user interface onderdelen kan terugvinden. Workbench De Workbench is het grafische beginpunt van Sheridan. Deze bevat het hoofdvenster samen met de WorkbenchLayout. Workbench Layout De Workbench Layout is verantwoordelijk voor het visualiseren en positioneren van alle grafische componenten die door de plugins worden toegevoegd. Voor grafische componenten bestaat er het onderscheid tussen Panels en Views. Een panel is een component dat maximaal 1 keer kan toegevoegd worden aan de Gui. Een View daarentegen kan 1 tot meerdere keren toegevoegd worden. Visueel bestaat er ook een onderscheid tussen panels en views. Zo gaat een panel een eigen titelbalk krijgen met een knop om het paneel te sluiten of te minimaliseren, terwijl views gegroepeerd worden in een tabblad structuur. Het laatste onderscheid dat we maken is het sluitgedrag, bij een panel gaat de ‘close’ knop het paneel enkel verbergen, terwijl een view volledig wordt gesloten en uit het geheugen wordt verwijderd.

Figuur 36 : Panels en Views

LogViewer De LogViewer is een standaard paneel dat alle informatieve berichten, waarschuwingen en fouten uit Sheridan gaat opvangen en visueel weergeven. Indien er een fout zou optreden in Sheridan is de gebruiker op deze manier in staat de oorsprong ervan op te zoeken en eventueel mede te delen aan de ontwikkelaars. De gebruiker is ook in staat om de log niveaus aan te passen via de Gui of via de executable config file. Aangezien het loggen van Sheridan gebaseerd is op log4net, een zeer uitgebreide logging library, zijn er tientallen verschillende log methodes met een heel aantal instellingen. Een volledig overzicht van deze instellingen kan je terug vinden op de log4net website, namelijk http://logging.apache.org/log4net/.


Figuur 37 : Logviewer

Solution Explorer De solution explorer is een panel dat verantwoordelijk is voor de visuale voorstelling van de huidige solution met al hun projecten. Dit paneel is ook verantwoordelijk voor het aanpassen van parameters van projecten. Dit door middel van de .NET property grid.

Figuur 38 : Solution Panel


Welcome Page De welcomepage is een view die tijdens het opstarten automatisch geladen wordt. De reden van ontwikkeling van de welcomepage is louter de weergave van de recent solutions.

Figuur 39 : Welcome page


Bug Panel Het bug panel wordt gebruikt om eventuele bugs te rapporteren aan het Sheridan Team zodat zij een bugfix kunnen schrijven. Het achterliggende systeem van deze bug panel is het gebruik van Bugzilla, een OpenSource bug tracking systeem van Mozilla.org waarbij gebruik gemaakt wordt van een Apache server met een MySQL database. Meer info vind u hier : http://www.bugzilla.org/about/

Figuur 40 : Bugzilla

Als de server om een of andere reden niet bereikbaar is, wordt een custom error page getoond.

Figuur 41 : Custom Error page


Sheridan.Database Database Schema Om ondersteuning te bieden aan het gebruiksgemak van Sheridan, werden de schemaproviders ontwikkeld. Schemaproviders maken het mogelijk de interne structuur van uw database weer te geven. Met interne structuur bedoel ik tabellen, kolommen, views, procedures en relaties. Dit maakt het niet alleen mogelijk om de interne structuur van uw database weer te geven, maar zo kan het randomizen van waarden volledig automatisch gebeuren.

Figuur 42 : Database Schema

Elke connection wrapper moet deze functionaliteit erven.


Connection Provider Een connection provider is een wrapper laag rondom een standaard .Net database provider. Deze klasse is dus verantwoordelijk voor het abstraheren van alle functionaliteit die beschikbaar is in de database provider. Een aantal mogelijkheden zijn onder andere het aanmaken van stored procedure calls en sql statements. Ook is het mogelijk een of meerdere commands te bundelen in een transactie. Deze functies geven een PooledCommand object terug. Dit object weeral een wrapper, ditmaal rond een standaard .NET Command object en een PooledConnection. Dit is nuttig omdat deze manier van werken het toelaat meerdere statements kort na elkaar uit te voeren zonder de connectie eerst terug vrij te moeten geven aan de ConnectionPool.

PooledCommand CreateStoredProcedure (string procedure); PooledCommand CreateSqlStatement (string sql);

Verder laat elke connectie provider het toe om de connectie naar de database daadwerkelijk te leggen als ook het testen van een connectie. void Connect (); bool TryConnect (out Exception e);

Connection Pool Ook al is er in .NET standaard ondersteuning voor connection pooling, hebben we er voor gekozen onze eigen connection pool te implementeren, dit omdat het gedrag van de standaard connection pool niet het efficiëntste is voor het uitvoeren van benchmarks. De standaard connection pool maakt gebruik van de .NET threadpool en voert een database command uit op een beschikbare thread. Dit werkt goed indien er sporadisch gebruik gemaakt wordt van de connections. Aangezien Sheridan de database connecties constant gebruikt gaan we elke connectie constant open laten zodat er geen tijdsverlies optreed bij het openen/sluiten van de connecties.

IPooledConnection RequestConnection ();

Haal een vrije connectie op uit de connection pool.

void ReleaseConnection (IPooledConnection connection);

Voeg de connectie toe aan de pool zodat deze kan hergebruikt worden.


bool HasFreeConnection { get; }

Kijk of er een connectie vrij is in de connection pool.

Pooled Commands IDataParameter AddParameter (string name, object value); IDataParameter AddParameter (string name, object value, bool isNullable);

Voeg een parameter toe aan het database command.

void Query ();

Voer een sql statement uit zonder een resultaat terug te keren.

object QueryAsObject ();

Voer een sql statement uit met als resultaat 1 object. Indien het sql statement meerdere rijen of kolommen terug keert gaat het object uit rij 0, kolom 0 geselecteerd worden.

DataTable QueryAsDataTable ();

Voer een sql statement uit met als resultaat een tabel van objecten. Deze methode werkt “buffered”, met andere woorden: alle resultaat rijen worden 1 voor 1 uitgelezen waarna de connectie gesloten wordt. Het voordeel aan deze methode is dat de sql connectie maar een zeer korte tijd gebruikt wordt. Het nadeel is dat deze methode zeer geheugen-intensief is.

DataSet QueryAsDataSet ();

Voer een sql statement uit met als resultaat een lijst van DataTable objecten. Deze methode is nuttig indien het sql statement uit meerdere select statements bestaat (multi-table select). Het resultaat wordt dan voor elk select statement in een apparte DataTable opgeslaan.

PooledDataReader QueryAsDataReader ();

Voer een sql statement uit met als resultaat een IDataReader. Deze methode werkt “streaming”, dit wilt zeggen dat de data niet in 1 groot geheel wordt uitgelezen, maar rij per rij wanneer de Read() methode wordt aangeroepen. Het voordeel van deze methode is dat zowel de performantie als het


geheugengebruik beter is dan QueryAsDataTable (), het nadeel is dat de connectie een lange tijd moet open blijven.

Opmerking: Aangezien de connectie voor een onbepaalde tijd open blijft (zolang de programmeur deze nodig heeft) is het niet mogelijk om de connectie automatisch te sluiten. Hierdoor is het belangrijk om de Dispose () methode aan te roepen nadat de connectie niet meer nodig is.

Echter, in C# bestaat er een using block die een object automatisch kan Disposen wanneer het niet meer nodig is. using (IDataReader reader = command.QueryAsDataReader ()) { … }

Ondersteunde Databases IBM UDB v8.x MySql 4.x/5.x Oracle 9i/10g PostgreSql 7.3+/8.x Microsoft SQL Server 2000/2005 Sybase ASE 12.x/15.x


Sql Parser ANTLR Wat is ANTLR De afkorting “ANTLR” staat voor “ANother Tool for Language Recognition”. Antlr is een recursive decent / LL(k) parser generator, maar wat wilt dit nu allemaal zeggen? Om te beginnen komen we bij het begrip “parser”. Een parser is een tool die in staat is om een bepaalde structuur in te lezen en te begrijpen. Een concreet voorbeeld hiervan is de C# compiler. De compiler gaat als eerste stap via een parser de code analyseren. Dankzij deze analyse weet de compiler of de syntax correct is en kan er echte machine (MSIL) code gegenereerd worden. Een parser generator daarentegen is een tool die aan de hand van bepaalde regels automatisch een parser kan maken. Dit is enorm handig aangezien een handgemaakte parser zeer tijdrovend en bijzonder complex is. Een recursive decent parser betekent dat het parsen “top-down” gebeurt. Dit wilt zeggen: men begint links vanboven en eindigt rechts beneden. Recursive decent betekent ook dat alle “regels” in de parser terecht komen in een aparte methode. De parser navigeert door het document door middel van het recursief aanroepen van parse methodes. Een volgende term die om uitleg vraagt is “LL(k)”. Dit duidt weer op het type parser. Andere mogelijke types zijn onder andere LR, LALR, SLR, … . De complete uitleg van de verschillen gaat echter ver buiten de gewenste moeilijkheidsgraad van deze uitleg, waardoor we enkel een korte uitleg van LL(k) geven. De eerste ‘L’ staat voor “Left to right” terwijl de 2e ‘L’ staat voor “Leftmost derivation”. Ten slotte duid ‘k’ op een positieve integer. Deze integer duid op het aantal tekens wat de parser vooruit moet kijken (“lookahead”). Zoveel te groter de lookahead, zoveel te trager te parser gaat reageren. Daarom is het zeer belangrijk om de parser zo goed mogelijk te optimaliseren. Zeer eenvoudig gesteld zijn er enkele grote verschillen tussen LL en LR parsers. LL parsers gaan namelijk sneller in staat zijn errors te detecteren in de syntax, daar er volgens dezelfde richting als de input wordt geparst. Een nadeel van LL parsers is dat de syntax om deze te definiëren complexer is dan LR parsers. Ten slotte bestaan er ook nog Finite State Machines, enkele bekende voorbeelden zijn tools zoals yacc en bison. De voordelen hiervan is dat deze tools vaak LR of LALR parsers genereren, wat het opstellen van de syntax beduidend eenvoudiger maakt. Een zeer groot nadeel is echter de “onnatuurlijke werking”. Daar waar recursive decent parsers perfect leesbaar zijn door mensen gaan finite state machines werken met lookup tabellen. Elke syntax regel wordt gekoppeld aan een numerieke waarde die vervolgens een sequentie voorstelt in een tabel. Deze manier van werken zorgt ervoor dat het debuggen van finite state


machines enorm complex en tijdrovend kan zijn en dat de automatische error reporting vaak ondermaats is. Waarom hebben we voor Antlr gekozen? En wat zijn de alternatieven ? Om te beginnen; er bestaan tientallen tot honderden parser generators, dit zorgt ervoor dat de juiste keuze maken niet altijd eenvoudig is. Onze keuze van programmeer platform, .NET, vereenvoudigt deze keuze echter. Aangezien er maar 3 parsers gratis ter beschikking zijn, namelijk Antlr, Coco/r en yacc(yacc is een tool geschreven in C, maar er is een Java port beschikbaar onder de naam “jay” die op zich weer naar .NET geport is). Een zeer belangrijk argument voor de keuze van Antlr, is de community er rond. Deze actieve community wordt geleid door Terence Parr, een docent aan de universiteit van San Francisco die al sinds 1989 aan dit project werkt. Dit zorgt ervoor dat er uitstekende documentatie te vinden is voor het gebruiken van Antlr. Een ander belangrijk argument is dat Antlr veel meer is dan gewoon maar een parser generator. Om dit te verduidelijken moeten we eerst de werking van een gewone parser onderzoeken. Stel, je werkt met het volgende Sql statement dat je wilt parsen SELECT * FROM myTable

De eerste stap die de parser gaat doen is een “Lexer” aanmaken. Een lexer is een onderdeel van de parser die verantwoordelijk is voor het opsplitsen van invoer documenten in kleine “tokens” (stukjes). Na het verwerken door de lexer krijgen we een lijst van tokens die er als volgt uitziet: SELECT

SELECT token

*

STAR token

FROM

FROM token

myTable

IDENTIFIER token

Een belangrijke taak van de Lexer is overbodige informatie reeds zo vroeg mogelijk kwijt spelen. In dit voorbeeld wordt alle white space genegeerd, aangezien dit voor Sql statements niet belangrijk is.

Bij de volgende stap schiet de parser zelf in werking. De parser is verantwoordelijk voor het valideren van de correcte volgorde van de tokens. Indien er bepaalde tokens voorkomen op ongewenste plaatsen kan de parser dit melden.


Tot aan dit punt gaan de meeste gewone parsers generators. Antlr gaat echter nog een stap verder en laat ons ook toe om “TreeParsers” te definiëren met dezelfde syntax als gewone lexers en parsers. Een tree parser maakt het mogelijk om de output van de parser om te zetten in een boomstructuur, deze boomstructuur kan vervolgens gebruikt worden om transformaties of dergelijke op toe te passen. Een simpel voorbeeld hiervan kan je vinden bij .NET, namelijk C# en VB.net. Stel, je hebt een parser die generic C# kan inlezen (List<MyType> lst). Indien je dit zou willen omzetten naar de VB.net variant (dim lst as List (Of MyType)) is dit mogelijk via een eenvoudige transformatie in de treeparser. Als laatste maar zeker niet onbelangrijk argument voor Antlr is de mogelijkheid om syntactic predicates te gebruiken. Een probleem dat zich voordoet bij vele LL(k) parsers, is dat de integer k altijd een maximum waarde heeft. Dit kan enorme problemen met zich meebrengen. Bedenk het params attribuut in C#, zo is het perfect mogelijk om de volgende functie void Test (params int[] ints)

aan te spreken als Test(1,2,3);

of Test(1,2,3,4,5,6,7,8,………100);

Aangezien er geen limiet zit op het aantal argumenten moet er ook een mogelijkheid zijn om “oneindige” lookup te doen, dit is mogelijk door middel van syntactic predicates. Grammar overerving Ook een zeer handige functie bij Antlr is het overerven van Grammars, zo is het bijvoorbeeld mogelijk om een basis lexer te maken die C stijl commentaar ondersteunt, en deze als basis te gebruiken voor zowel C als C++ lexers. Waarvoor gebruiken we het ? • QueryScript •

Sql Parsers

Uitgebreide beschrijving Een volledig overzicht van Antlr kan je terugvinden in de Antlr reference manual, op de volgende url: http://www.antlr.org/doc/index.html. Gebruik in Visual Studio Om te beginnen heb je de laatste versie van Antlr nodig (2.7.6 op het moment van schrijven) als ook een recente versie van de java runtime environment.


Figuur 43 : ANTLR

Om te beginnen gaan we naar de “External Tools” configuratie. Hier voegen we een item toe met de naam “Antlr”. Dit item wordt gebruikt om grammar files te compileren naar C# code. Bij het commando veld vullen we “java.exe” in. Om ervoor te zorgen dat dit geldig is moet de java directory eerst toegevoegd worden aan de windows PATH environment variabele. Ten slotte stellen we de argumenten in. -cp D:\ANTLR\antlr-2.7.6\antlr.jar antlr.Tool -o $(ProjectDir) $(ItemPath)

Dit zorgt ervoor dat bij het klikken op Tools/Antlr de Antlr executable wordt aangeroepen met de geselecteerde .g file.


Figuur 44 : External Tools

Verder bestaat er in Antlr ook de mogelijkheid om grammars over te erven. Zo is het bijvoorbeeld mogelijk om 1 basis Sql parser te maken en elk Sql dialect deze parser te laten overschrijven en wijzigingen aanbrengen. Om dit te bereiken hebben we een .bat file nodig, dit aangezien de totale lengte van het commando meer dan 255 tekens bedraagt, en dit niet werkt als external tool bij visual studio. @echo off cd %1 java -cp D:\ANTLR\antlr-2.7.6\antlr.jar antlr.Tool -glib %1Sheridan.SqlParser/BaseSqlParser.g -o %2 %3

Dit commando slaan we op als een .bat bestand dat we gebruiken in het Command veld bij external tools. Hierna moeten we er enkel nog voor zorgen dat de parameters in dit script worden opgevuld, dit kan door middel van de volgende instellingen in het Arguments veld: $(SolutionDir) $(ProjectDir) $(ItemPath).


Figuur 45 : Instellen ANTLR

Waarom? Om het waarom te beantwoorden moet je een beter begrip hebben van de visie van Sheridan. Een van de vereisten is namelijk het randomizen van sql statements. Dit is een zeer belangrijk onderdeel bij database benchmarks. Moest dit niet gebeuren zou een slimme database in staat zijn om resultaten te bufferen met behulp van een query cache, iets wat ongeldige benchmark resultaten zou opleveren. Om dit te bereiken moet Sheridan in staat zijn de parameters van een sql statement op te vullen met willekeurige waarden. Om het opvullen zoveel mogelijk te automatiseren hebben we een sql parser ontwikkeld, hierdoor zijn we in staat om automatisch alle parameters te herkennen in een sql statement, wat veel werk bespaart voor de gebruikers. Bijvoorbeeld: SELECT * FROM myTable WHERE id > @id

In dit statement wordt ‘@id’ herkent al seen parameter. Een bijkomende functionaliteit van de Sql parser is het herkennen van literals, bijvoorbeeld numerieke waardes of strings die voorkomen in een statement. Dit maakt het ook mogelijk om queries zonder parameters te verwerken. Bijvoorbeeld: SELECT * FROM myTable WHERE id > 100


In dit statement wordt ‘100’ herkent als een literal. Het is dan mogelijk om in dit statement de vaste waarde ‘100’ om te zetten in een parameter. Hierdoor zijn we in staat om specifieke sql statements zonder al te veel input van de gebruiker om te vormen in statements met willekeurige waarden. Verschillende Dialecten Verder is het ook zeer belangrijk dat er ondersteuning geboden wordt voor verschillende sql dialecten. Stel je wil een rij met id x uit de tabel personen halen, de syntax hiervan kan verschillend zijn voor bepaalde databases, bijvoorbeeld: MySql SELECT * FROM personen WHERE id = @id

PostgreSql SELECT * FROM personen WHERE id = :id

Zoals je kan zien is het gebruik van parameters verschillend voor beide databases. De parser moet hiermee rekening houden.


SQL:1999 Overview Introductie Als eerste en meest gebruikte parser hebben we een parser geïmplementeerd die de Sql:1999 syntax ondersteund, samen met een aantal veelgebruikte database specifieke statements. SQL:1999 is een Sql standaard ook bekend onder de naam Sql 3 of “ISO/ANSI/IEC 9075”. Deze parser ondersteunt een gedeelte van deze standaard, namelijk DML (data manipulation language). Dit hoofdstuk gaat een overzicht geven van alle ondersteunde regels. Notatie Alle vierkante haakjes en Accolades die in dit document voorkomen maken geen deel uit van de Sql statements, maar ze worden gebruikt als hulpmiddel om de syntax te definiëren.

Vierkante haakjes worden gebruikt om een keuze aan te duiden, bijvoorbeeld [x | y | z]. Dit betekents dat ofwel x, y of z kan voorkomen.

Accolades worden gebruikt om optionele delen aan te duiden. Bijvoorbeeld, je hebt een statement x dat optioneel gevolgd kan worden door statement y, dan wordt dit als volgt aangeduid x{y}. Bronnen http://aam.ugpl.de/?q=node/227

ISO/ANSI/IEC 9075 http://docs.openlinksw.com/virtuoso/sqlreference.html


Literals Strings ‘’ Lege string ‘some string’

een string

‘’’’

‘ char

‘’’ ’’’

‘ ’ characters

‘”’

“

‘”string”’

“string”

‘\012’ octaal character 12 (= \n) ‘\n\r\t\\’

newline, carriage return, tab and backslash

Numbers 123 positieve integer -123 negatieve integer 123.45 .45

floating point nummer

floating point nummer

-6.3e3

exponent

-6.3e-3

exponent

+3

positieve integer

Hexadecimal X’aabb’ geldig X’2345’

geldig

0x1234

geldig

X’12345’

ongeldig (hex characters komen altijd per 2)

X’’

ongeldig

X’value’ is equivalent aan 0xvalue Binary B’1’ 0x01


B’1111’ B’’

0xFF

Empty byte array

Time ‘1999-12-31’

date

‘1999-12-31 12:00:00’ ‘Jan 01, 2002’ date

timestamp

Constante literals Null null literal True Boolean true False Boolean false Commentaar Enkele lijn --dit is commentaar Meerdere lijnen /* dit is commetaar*/

Operatoren Wiskundig + Plus -

Min

*

Maal

/

Gedeeld

%

Modus

Numerieke vergelijking < Kleiner dan <=

Kleiner dan of gelijk aan

>

Groter dan

>=

Groter dan of gelijk aan


Vergelijking = Gelijk aan <>

Niet gelijk aan

Logisch AND Logische en OR

Logische of

ANY BETWEEN EXISTS IN LIKE NOT SOME ALL Andere IS NULL | NOT NULL (

linker haakje

)

rechter haakje

Data types ‘lengte’ is een numerieke waarde van het type INT. Character CHAR{ACTER}{(lengte)} VARCHAR{( lengte)} Numeric NUMERIC{( lengte {, lengte })} Decimal DEC{IMAL}{( lengte {, lengte })} Integer INT{EGER} SMALLINT


BIGINT Float FLOAT{( lengte)} DOUBLE PRECISION REAL {NUMBER} Time TIME DATE TIMESTAMP DATETIME Andere BLOB Statements Alle statements worden afgesloten door een puntcomma ‘;’. Select SELECT [* | {[DISTICT | ALL]} expressie [AS alias] {, expressie [AS alias]}* ] {FROM} {WHERE} {GROUP BY} {HAVING} {UNION} {ORDER BY {JOIN} Insert INSERT [INTO | REPLACING | SOFT] tabel {(column {, column}*)} [VALUES (waarde {, waarde }*) {, (waarde {, waarde }*)} | select statement ]

NOTE: Alle colommen die niet nullable zijn moeten een correcte waarde meekrijgen.


Update UPDATE tabel SET column = waarde {, column = waarde }* {WHERE zoek criteria} Delete DELETE FROM tabel {WHERE zoek criteria} Truncate TRUNCATE TABLE tabel Drop DROP TABLE tabel DROP INDEX tabel.index DROP DATABASE db Clauses From FROM tabel {AS identifier} FROM tabel {identifier} Where WHERE [Column identifier [operator expressie | | {NOT} [BETWEEN expressie AND expressie | IN [range | select statement] | LIKE string ] ] | {NOT} EXISTS [range | select statement] ]


Having Zie where Group By GROUP BY [column identifier | column index] {, [column identifier | column index]}* Order By ORDER BY [column identifier | column index] {, [column identifier | column index]}* {[ASC | DESC]} As Identifier AS Identifier Join [INNER | [FULL | RIGHT | LEFT {OUTER}] | CROSS JOIN] tabel ON expressie Union [UNION {ALL} | INTERSECT | EXCEPT {ALL}] Predicates Limit [LIMIT int COMMA int] Like LIKE string literal

De string kan ook een wildcard patroon bevatten. Functies CAST CAST (expressie AS data type) Converteer het resultaat van een expressie naar een specifiek (compatibel) data type. Data Aggregatie AVG AVG (expressie) Bereken de gemiddelde waarde voor een reeks waarden. COUNT COUNT (expressie) Bereken het aantal items in een reeks.


SUM SUM (expressie) Tel alle waarden van een reeks op. MIN MIN (expressie) Bereken de minimale waarde van een reeks getallen. MAX MAX (expressie) Bereken de maximale waarde van een reeks getallen. STDDEV STD{D}EV (expressie) Standaard deviatie VARIANCE VAR{IANCE} (expressie) Variantie Wiskundig ABS ABS (numerieke waarde) Absolute waarde CEIL CEIL{ING} (numerieke waarde) Rond een numerieke waarde af naar boven. FLOOR FLOOR (numerieke waarde) Rond een numerieke waarde af naar onder. ROUND ROUND (numerieke waarde, lengte {, functie}) Rond een numerieke waarde af volgens de standaard wiskundige regels en met een bepaalde precisie. SQRT SQRT (numerieke waarde) Vierkantswortel


Text LENGTH LENGTH (string) Bereken de lengte van een string. LEFT LEFT (string, numerieke waarde)

RIGHT RIGHT (string, numerieke waarde) SUBSTR SUBSTR{ING} (string, start {, lengte}) Date and Time CURRENT_DATE Huidige datum CURRENT_TIME Huidig tijdstip DATE Huidige datum DAY Huidige dag MONTH Huidige maand WEEKDAY Huidige dag van de week YEAR Huidig jaar


Identifiers Identifier grootte De maximale grootte van een identifier hangt af van de database, hieronder een kort overzicht.

Microsoft SQL Server 2000/2005

128 characters

MySQL 4.x/5.X

64 tekens

IBM DB2 8.x

128 tekens

Oracle 9i/10g

30 bytes

PostgreSql 7.3+/8.x

31 tekens

Sybase ASE 12.5

128 tekens

Identifier name Alle namen moet met een alfabetische waarde beginnen. Voor de rest mag de naam alle alfanumerieke waarden bevatten, als ook het underscore (_) teken.

Quoted identifiers Quoted identifiers worden gebruikt wanneer er gebruik gemaakt wordt van spaties in een identifier. De meeste databases ondersteunen dit door middel van het quote (“) teken. Er zijn ook een aantal toevoegingen hierop. MySql ondersteund namelijk ook het single-quote (‘) teken terwijl Microsoft Sql Server en Sybase hiervoor ook vierkante haakjes gebruiken ([]).


QueryScript Wat is QueryScript Ontstaan Om de bestaansreden van QueryScript beter te begrijpen, gaan we eerst een beter overzicht geven van de oude benchmark situaties. Stel je komt in een situatie terecht waarin een bedrijf zijn database applicatie wil testen aan de hand van MySql, PostgreSql en Microsoft sql Server. In dit geval zou het bedrijf verplicht zijn 3 benchmarks aan te maken die er bijna exact hetzelfde uitzien, met als enige verschil de gebruikte sql statements. Hiervoor hebben we QueryScript ontwikkeld, met als voornaamste mogelijkheid de scheiding van structuur en sql statements. Hierdoor is de tester in staat om eenmalig de structuur van de test op te stellen en voor elke database die je wilt testen de sql statements op te vullen. Structuur Wat moet je nu precies inbeelden met het woord “structuur”. Een structuur wordt gebruikt om de uitvoeringsvolgorde van de benchmark te definiëren en aanpasbaar te maken. Om dit beter te begrijpen kunnen we weer gebruik maken van een voorbeeld uit het echte leven. Stel je hebt een website die gebruikt wordt om nieuwsberichten te plaatsen op het internet. De voorpagina van deze website gaat bijvoorbeeld de laatste 10 berichten tonen, samen met de naam van de bron. Als je dit voorbeeld bekijkt in de vorm van sql statements krijg je 1 sql statement dat de eerste 10 berichten gaat ophalen en hierna voor elk nieuwsbericht een sql statement om de naam van de bron op te halen. Indien je queryscript zou toepassen op dit voorbeeld, krijg je een eenvoudige structuur die definieert dat je 1 sql statement hebt, en een ander sql statement dat voor elke resultaat rij 1x wordt uitgevoerd. Taal specificaties Referenties C# ECMA-334 (C# standaard) Afkortingen CLR Common Language Runtime Grammatica Alle keywords zijn hoofdlettergevoelig en worden altijd zonder hoofdletters genoteerd. De grammatica is gebaseerd op een combinatie van C# en javascript en de scripttaal wordt gecompileerd naar .NET 2.0 compatibele assemblies, dit met behulp van de Sheridan.AssemblyGenerator tussenlaag.


Commentaar Aangezien QueryScript toelaat om zeer complexe database benchmarks te definiëren, is het gebruik van commentaar zeker en vast niet overbodig. Daarvoor ondersteund QueryScript 2 verschillende soorten commentaar, namelijk commentaar op 1 regel en commentaar verspreid over meerdere regels. De syntax volgt de richtlijnen van de C# standaard. // dit is commentaar op 1 regel /* dit is commentaar verspreid over meerdere regels */

Literals Literals zijn stukken tekst of nummers die “letterlijk” in de code voorkomen. Aangezien QueryScript een taal is die draait boven op de .NET 2.0 CLR, heeft het ondersteuning voor alle beschikbare literals. Strings Strings zijn stukken tekst die letterlijk in de syntax voorkomen en worden aangeduid door quotes (“). Indien je speciale karakters in een string wilt gebruiken kan dit op dezelfde manier als in C#, namelijk via “escape sequences”.

“dit is een string” “” // dit is een lege string “dit is een string\n met een enter” \n \r \t \f \” \\

new line line feed tab form feed quote backslash

Numerieke waardes QueryScript ondersteund de meeste numerieke data types uit de CLR. Integers Voorbeeld: 1, 15, … Bereik: -2147483648 tot 2147483647

Unsigned Integers Voorbeeld: 1U, 15u, … Bereik: 0 tot 4294967295

Longs


Voorbeeld: 1L, 15l, … Bereik: -9223372036854775808 tot 9223372036854775807

Unsigned Longs Voorbeeld: 1UL, 15lu, 150uL, … Bereik: 0 tot 18446744073709551615

Floats Voorbeeld: 1F, 15f, 1.5f, … Bereik: ongeveer ±1.5 x 10-45 tot ±3.4 x 1038

Doubles Voorbeeld: 1.0, 1D, 15d, … Bereik: ongeveer ±5.0 x 10-324 tot ±1.7 x 10308

Decimals Voorbeeld: 1M, 15m, … Bereik: ongeveer ±1.0 x 10-28 tot ±7.9 x 1028

Booleaanse waardes QueryScript biedt ondersteuning voor booleaanse waardes . true false

//waar //onwaar

Speciale waardes QueryScript ondersteund 2 verschillende soorten “speciale” waardes, namelijke niet geïnitialiseerde en lege waardes null //deze waarde kan gebruikt worden om een variabele te vergelijken met een niet geïnitialiseerde waarde empty //deze waarde kan gebruikt worden om een variabele te vergelijken met een lege waarde


Variabelen Er zijn 4 verschillende types variabelen beschikbaar in QueryScript. Query Een variabele van het type “query” wordt gebruikt om een dialect specifiek SQL statement op te slaan en op een later tijdstip uit te voeren met de execute functie. Dit type variabelen kan alleen maar gedefinieerd worden en er is geen initialisatie mogelijk. query myQueryVar;

Parameter Een variabele van het type “parameter” is net zoals een query variabele dialect specifiek en kan ook alleen maar gedefinieerd worden. Parameter variabelen worden gebruikt om veranderlijke waardes in een SQL statement aan te duiden. parameter myParam;

Row Een variabele van het type “row” wordt gebruikt om een rij weer te geven in het resultaat van een uitgevoerde query. Deze variabele kan overal gedefinieerd worden maar kan enkel geïnitialiseerd worden door het foreach statement. row myRow;

Var Voor alle andere data types wordt een variabele van het type “var” gebruikt. var var var var var …

v1; //de waarde in v1 is ‘null’ v2 = “test”; //v2 is van het type string v3 = 100; //v3 is van het type integer v4 = 15.0; //v4 is van het type double v5 = true; //v5 is van het type boolean


Expressies Een expressie is een stuk code dat een bepaald resultaat terug keert, bijvoorbeeld het vergelijken van 2 variabelen of het optellen van 2 integers. Expressies kunnen onderverdeeld worden in verschillende categorieën. Wiskundige expressies Onder de categorie wiskundige expressies vallen 5 verschillende expressies: plus (+), min (-), maal (*), gedeeld (/) en modus (%). Zonder scheiding door middel van ronde haakjes volgen deze operatoren de standaard wiskundige volgorde, namelijk *, /, %, +, -. 5 + 3 5 * 4 / 3 …

Ook is het mogelijk deze wiskundige operatoren in een niet-wiskundige context te gebruiken, zoals bijvoorbeeld het samenvoegen van 2 strings. var str = “een” + “ “ + test;

Verder is het ook mogelijk beide mogelijkheden te combineren, de enige beperkingen hierbij zijn de beperkingen van het .NET platform. var str = “string #” + 1; var err = 1 + “string”; //deze bewerking is niet geldig, aangezien de expressie ‘1’ het type van de //variabele ‘err’ intern op integer gaat plaatsen, waardoor het dus niet //mogelijk is om er een string aan toe te voegen.

Vergelijkende expressies Er zijn vele verschillenden vergelijkende expressies, namelijk: gelijk aan (==), niet gelijk aan (!=), groter dan (>), groter dan of gelijk aan (>=), kleiner dan (<) en kleiner dan of gelijk aan (<=). Ook zijn er nog 2 speciale vergelijkende expressies, die als specifiek doel hebben 2 strings op een hoofdletter ongevoelige manier met elkaar te vergelijken, namelijk: gelijk aan (===) en niet gelijk aan (!===). a == 100 “test” === “Test” b <= 1.5 …

Opmerking: Indien 2 variabelen van verschillende types vergeleken worden gaat er geen compileer of runtime fout optreden, maar gaat het resultaat altijd equivalent zijn aan ‘false’. Booleaanse expressies Booleanse expressies stellen ons in staat meerdere vergelijkende expressies aan elkaar te koppelen. Er zijn 3 verschillende soorten beschikbaar, namelijk en (&&), of (||) en niet (!).


a == 100 && b == 200 (“test” === “Test” || !(a == b))

Opmerking: De ‘en’ expressie is een ‘luie’ expressie, dit wil zeggen indien de eerste vergelijkende expressie ‘false’ is dat de 2e vergelijkende expressie niet gaat uitgevoerd worden. Execute De execute functie wordt gebruikt om een query variabele uit te voeren en het resultaat op te slaan in een variabele van het type “var” Bij het uitvoeren van een query bestaan er 4 verschillende uitvoeringsmogelijkheden: Streaming Deze uitvoeringsmodus gaat het query resultaat overlopen via een DataReader, dit is de snelste manier en is ook de standard uitvoeringsmodus. Buffered Deze uitvoeringsmodus gaat het query resultaat bufferen in een DataTable, deze methode is aanzienlijk trager dan de streaming methode en is alleen nuttig in extreme situaties (bijvoorbeeld: een zeer hoge latency op de netwerkverbinding van de database client naar de database server). Object Deze uitvoeringsmodus geeft geen lijst van resultaten terug, maar 1 enkel object, indien de SQL query wel meerdere rijen terug zou keren, gaat het object uit de eerste kolom van de eerste rij gebruikt worden als resultaat. Void Deze uitvoeringsmodus gaat geen resultaat terugkeren, indien het resultaat van deze functie toch in een object van het type “var” wordt gestoken komt dit overeen met de waarde van de “empty” literal. execute (myQuery, void); var result = execute (myQuery, streaming);

Get Deze functie wordt gebruikt om een bepaald object uit een resultaat rij te halen. var x = get (myRow, 0); var name = get (myRow, “name”);


Statements Debug Als eerste en misschien wel belangrijkste statement is er het “debug” statement. Via deze functie kunnen boodschappen of waardes van variabelen gelogd worden tijdens het uitvoeren van de benchmark. Dit is een onmisbare functie voor het controleren van de correctheid van de benchmark. debug (“dit is een boodschap”); debug (“de waarde van variabele a = “ + a);

Status De status functie wordt gebruikt om het uitvoer resultaat van een blok code weer te geven. Deze functie is optioneel, aangezien er standaard de waarde “ok” en een lege boodschap wordt gebruikt na het uitvoeren van een QueryScript functie. Indien er iets mis gaat tijdens het uitvoeren van een blok code, kan er gebruik gemaakt worden van de “warning” of “error” status, eventueel in combinatie met een boodschap. status (ok); status (error); status (warning, “Er zijn 0 resultaat rijen”);

Toekenning Het toekenning statement is een van de eenvoudigste statements. Dit statement gaat een bepaalde waarde (alle expressies) toekennen aan een reeds eerder gedefinieerde variabele. var i = 100; var name = “Ben Motmans”; var sum; sum = 5 + 5;

Set parameter Deze functie wordt gebruikt om een variabele van het type “parameter” op te vullen met een bepaalde waarde. set_parameter (myQuery, myParam, 1 + 2); set_parameter (myQuery, myParam, get (myRow, 0)); set_parameter (myQuery, myParam, “test”);

Foreach Het “foreach” statement wordt gebruikt om het resultaat van een query te overlopen, rij per rij. Elke rij wordt beschikbaar gemaakt via een variabele van het type “row”. row r; foreach (r in myQueryResult) { var myName = get (r, “name”); }


Het is ook mogelijk om de declaratie van de row variabele te doen binnen het foreach statement. foreach (row r in myQueryResult) { … }

While Het “while” statement is een blok code die gaat uitgevoerd worden zolang er aan een bepaalde voorwaarde voldaan blijft. var i = 0; while (i < 10) { i = i + 1; debug (i); } //deze blok code gaat van 0 tot 9 tellen

Opmerking: Zorg er voor dat de stop voorwaarde altijd bereikbaar is, aangezien een oneindige lus de benchmark zal doen vastlopen. voorbeeld van een oneindige lus is als volgt: while (true) { … }

If / Else If / Else Het “if” statement wordt gebruikt om bepaalde blokken code uit te voeren in specifieke scenario’s. Hiervoor gaat er gebruik gemaakt worden van een vergelijkende expressie om te controleren of de code blok moet uitgevoerd worden. Ook is er de mogelijkheid om via “else if” statements alternatieve code blokken uit te voeren. Tot slot kan het “else” statement gebruikt worden indien alle vorige alternatieven niet geldig waren. if (name === “ben”) { achternaam = “Motmans”; } else if (name === “brecht”) { achternaam = “Kets”; } else if (name === “sam”) { achternaam = “Van Broek”; } else { achternaam = empty; }

Inline Code Indien de beschikbare QueryScript syntax nog altijd onvoldoende is om een volledige benchmark op te stellen, kan er ook nog altijd gebruik gemaakt worden van inline code. Dit wil zeggen dat er rechtstreeks gebruik gemaakt wordt van C# code op bepaalde plaatsen in de benchmark. Expressies Indien je een bepaalde waarde aan een QueryScript variabele wilt toekennen aan de hand van een C# statement, kan dit gebeuren via de expressie tags, namelijk <% en %>. var v1 = <%= “een string” %>; //dit komt overeen met


var v2 = “een string”; //om een meer complex voorbeeld te geven var v3 = <% String.Concat (“een”, “ “, “string”); %>;

Statements Indien je een grote blok code wilt toevoegen als een statement, kan je gebruik maken van de statement tags, namelijk <% en %>. <% Console.WriteLine (“dit is een C# statement.”); %>;

Voorbeeld query qry0; var qryResult0 = execute (qry0, buffered); foreach (row qryRow0 in qryResult0) { query qry1; parameter name; set_parameter(qry1, name, get(qryRow0, 0)); var qryResult1 = execute (qry1, buffered); foreach (row qryRow1 in qryResult1) { } }

In dit voorbeeld gaat qry0 eerst uitgevoerd worden als een buffered query. Hierna gaan alle resultaat rijen van deze query overlopen worden. Voor elke rij gaat er dan een nieuwe query aangemaakt worden aan de hand van de waardes uit de geselecteerde rij. Compiler Als laatste onderdeel van QueryScript is er de compiler. Dit onderdeel is verantwoordelijk voor het omzetten van de QueryScript code naar een assembly die uitvoerbaar is op het .NET 2.0 platform. In de eerste stap van de compiler wordt het resultaat van de parser omgezet naar een boom-structuur, dit gebeurt door middel van een TreeParser. In de volgende fase moet deze boomstructuur omgezet naar een intern objectmodel in Sheridan. Op dit moment zijn er ook al een aantal controle’s uitgevoerd op de QueryScript code, namelijk dat er geen variabelen zijn met dezelfde naam in 1 bepaalde scope. In de laatste fase van de compiler gaat dit objectmodel omgezet worden naar een uitvoerbare assembly, dit gebeurt door de onderliggende AssemblyGenerator laag. In deze fase wordt er ook een ObjectPool aangemaakt die de benchmark in staat stelt willekeurige waardes aan parameters toe te kennen. Als dit alles zonder fouten gebeurt, is de benchmark klaar om uitgevoerd te worden.


Dynamic Code Application Domain Assembly Resolve Een van de nadelen van het maken van dynamische assemblies in het geheugen, is het opzoeken van dependencies. Aangezien we de dynamische assemblies compileren met referenties naar een aantal libraries in het Addins/ mapje in de Sheridan directory moeten deze assemblies ook beschikbaar zijn als we de dynamische code gaan uitvoeren. Echter, dankzij de werking van de Assembly LoadFrom methode gaan enkel assemblies in de GAC of in dezelfde directory als de executable gevonden worden. Om dit probleem op te lossen kunnen we een callback toevoegen aan het AssemblyResolve event van het huidige Application Domain. Dit event laat ons toe om alle assembly lookups die falen manueel op te lossen.


Sheridan.Monitoring Het monitoring gedeelte van Sheridan bestaat uit twee gedeeltes. Het eerste gedeelte is een puur monitoring gedeelte waarbij zowel de client als de server bevraagt worden op hun CPU percentage, memory, enzovoorts.

Figuur 46 : Performance monitor

Het tweede gedeelte bestaat uit het analyseren van config files van onder andere database config files. Dit stuk bestaat grotendeels uit de samenwerking met het research team. In een volgende versie van Sheridan zal het de bedoeling zijn de verkregen config files te vergelijken met de hoog geoptimaliseerde config files en op basis van beide documenten een zo geoptimaliseerd mogelijke file terug te geven voor die bepaalde server. Het verkrijgen van de server informatie gebeurt via het SIMC protocol en Balvenie, een C++ socket. Client monitoring De informatie voor het client monitoring wordt opgevraagd via Performance Counters die in een monitoring Service geïmplementeerd zijn. Via deze service kan men van overal deze waardes opvragen. Dit is was nodig omdat de gemiddelde CPU tijd per Benchmark run moet bijgehouden worden om zo zeer snel en gemakkelijk de belasting van de CPU's te monitoren. Sheridan monotoring SIMC Protocol Server Information stream to Master Client is een protocol ontworpen met als doel server info6 te kunnen doorspelen aan de Sheridan Master Client, hierna verder gerefereerd als SMC. Deze info wordt grafisch of tekstueel weergegeven op de client zodat men gemakkelijk de belasting van bijvoorbeeld de CPU kan monitoren. Werking Er is een opsplitsing gemaakt tussen info dat éénmalig gestuurd wordt en info dat via een bepaald patroon en ritme wordt opgestuurd. Voor de éénmalige info

6

OS informatie, CPU, memory, …


maken we gebruik van het SOAP protocol om een beschrijvend XML object door te sturen waarin alles staat. Meer info hierover kun je terugvinden onder XML Soap Protocol. Het tweede deel bestaat uit een Punt Komma delimited protocol. Deze heeft als doel om snel en met zo weinig mogelijk overkill, info door te sturen naar de SMC. Ook wordt via deze manier de éénmalige info opgevraagd. Meer info hierover kun je terugvinden onder het Punt Komma delimited protocol. Alle communicatie verloopt via de poort 2315. Punt Komma delimited protocol Éénmalige info opvragen De éénmalige info kan op elk moment opgevraagd worden. Het is echter aan te raden dat dit gebeurt voordat de informatiestroom (het monitoren), hierna verder gerefereerd als IS, gestart wordt. Dit gebeurt via het commando Get Server Information as XML Object. gsixo;

Hierop krijg je volgend antwoord : XML;bufferlengte;xml object

waarbij bufferlengte een integer7 waarde is die de grootte van de receive buffer aangeeft. Informatiestroom starten Als eerste wordt er een request doorgestuurd om de IS te starten. De eerste parameter is het commando SIMC. De tweede parameter staat voor het aantal milliseconden waarop de server zijn info moet doorspelen. Deze parameter heeft als minimum 100 en is steeds een veelvoud hiervan. simc;100;

Informatiestroom stoppen De IS wordt gestopt via het commando Close SIMC. csimc;

Soorten informatiestromen Dit zijn de responswaarden van de server. Deze waarden kunnen ook apart opgevraagd worden door de SMC. De responswaarden worden gebruikt door de SMC om de gebruiker op de hoogte te houden hoe zijn server presteert op dat specifieke moment. Dit is de eigenlijke monitoring.

7

geheel getal


De opbouw van het respons commando gaat als volgt : is;var;waarde1;waarde2;…;

Is : InformationStream Var : dit is de integer representant van de (gevraagde) waarde die terug te vinden is tabel 1. Waarde(1)(2)(…) : dit is de specifiek gevraagde data. Bij meerdere data velden (bijvoorbeeld bij meerdere CPU's) wordt de data gescheiden door een ;. Representant

Waarde

0

CPU verbruik

1

CPU totaal verbruik

2

Aantal CPU's

3

Geheugen verbruik

4

Swap verbruik

5

Config file

Tabel 1 : Opvraagbare waarden van de server

De SMC kan ook specifieke data opvragen zonder een stream van info te willen. Het is echter afgeraden dit te doen wanneer een IS gestart is. De opbouw van het request commando gaat als volgt : gi;var;

Gi : Get Information Var : dit is de integer representant van de (gevraagde) waarde die terug te vinden is in tabel 1. Foutieve data Om een fout aan te geven kan men gebruik maken van het error commando. Dit telt zowel voor de client als de server. error;foutboodschap;

Config files Config files kunnen op een zelfde manier verstuurd worden. Men geeft het binaire startsignaal via volgende manier : config;bufferlengte;configfile


XML Soap Protocol Onder éénmalige informatie verstaan we vaste waarden zoals gebruikt OS, aantal CPU's, enzovoorts. Om deze info op te vragen maken we gebruik van het Punt Komma delimited protocol. Het versturen van deze info gebeurt echter via een XML object. Dit gebeurt via het SOAP protocol. Het XML object zelf is straightforward en spreekt voor zichzelf. Onder de tag computer komen alle individuele CPU's te staan. <SIMC> String String String String String int int int String String String


<memory> long long long long


Balvenie Wat is Balvenie? “Balvenie” is de code naam voor de server side performance monitor. De visie van Balvenie is een tool te ontwikkelen in C++ die native compileert naar Windows, linux en solaris om zo de performantie van de server te volgen tijdens het benchmarken. Waarom C++ ? De keuze is gevallen op C++ omdat we veel hardware informatie moeten opvragen, deze informatie is vaak alleen op te vragen via low-level libraries. Op dit gebied is het eenvoudiger om met C of C++ te werken dan “hogere” managed talen zoals .NET of java. Ten opzichte van C hebben we C++ gekozen door de betere object georiënteerde ondersteuning. Mogelijkheden • operating system: versie/build ophalen •

systeem: hostname / platform

•

hardware

•

fysiek geheugen (gebruik / totaal)

•

swap geheugen (gebruik / totaal)

•

aantal processoren

•

aantal processoren die ingeschakeld zijn

•

gecombineerde CPU load

•

CPU informatie (model, snelheid en attributen)

Al deze informatie kan aan de server kant verzameld worden. De Sheridan client kan vervolgens een TCP connectie opzetten naar de server, de specificaties hiervan zijn beschreven onder de naam “SIMC” protocol. Naar de toekomst Naar de toekomst toe zijn er 2 verschillende visies voor Balvenie. Als eerste gaat de monitoring functionaliteit verder uitgebreid worden. Alle operating systems zullen volledige ondersteuning krijgen voor alle bovengenoemde mogelijkheden. Ook is het de bedoeling dat er een monitoring systeem voor de netwerkverbinding wordt toegevoegd. Als 2e deel gaat Balvenie fungeren als een analyse tool voor databases. Door middel van het uitlezen en interpreteren van database configuratie files


gecombineerd met de kennis van Balvenie over het systeem gaan er tuning suggesties worden gedaan voor de database. Hier komt echter ook enorm veel menselijke expertise bij te pas, aangezien er eerst onderzoek moet gedaan worden naar het tunen van een database, voordat we er advies over kunnen geven.


Sheridan.Threading Algemeen Daar Sheridan in staat moet zijn om meerdere gebruikers te simuleren, is het threading-mechanisme van vitaal belang. De .Net threadpool voldoet niet aan onze eisen omdat we er te weinig controle over hebben en er geen monitoring is inbegrepen. Het is ook algemeen bekend dat wanneer een thread voor een lange tijd moet werken, je best de .NET threadpool niet gebruikt. We hadden dus nood aan een robuust threading mechanisme. Waarom juist een threadpool en niet enkel de threads vanuit uw benchmark beheren? De reden is dat je zo veel meer controle hebt over de threads. Vele applicaties hebben threads die negentig procent van de tijd liggen te wachten tot er iets gebeurd. De Sheridan threadpool zorgt ervoor dat de werk-threads door een master-thread gecontroleerd worden. Deze threadpool is gebaseerd op Ami Bar’s Threadpool. Functies • Work items kunnen een waarde teruggeven •

De aanroeper kan wachten tot meerdere functies klaar zijn.

•

De aanroeper kan wachten tot alle functies klaar zijn.

•

Work items kunnen geannuleerd worden.

•

De threadpool kan geannuleerd worden.

•

De threadpool moet work items met een ingesteld aantal threads uitvoeren.

•

Robuust error handling systeem.

Voorbeeld De threadpool kan op volgende manier gebruikt worden: StartInfo tpStartInfo = new StartInfo (); tpStartInfo.IdleTimeout = 1000; tpStartInfo.NumWorkerThreads = 100; tpStartInfo.PerformanceCounterInstanceName = "Test ThreadPool"; ThreadPool threadPool = new ThreadPool (tpStartInfo); Threadpool.Start(); for (int i = 0; i < functionCount; i++) { pool.QueueWorkItem (new WorkItemCallback (functie), parameter); }

Monitoring In de threadpool is er ook monitoring functionaliteit ingebouwd. Deze kan je aanspreken via performance counters. PerformanceCounter pcWorkItemsPerSec = new PerformanceCounter (); pcWorkItemsPerSec.BeginInit ();


pcWorkItemsPerSec.CategoryName = "ThreadPool"; pcWorkItemsPerSec.CounterName = "TYPE PERFORMANCE COUNTER"; pcWorkItemsPerSec.InstanceName = "Test ThreadPool"; pcWorkItemsPerSec.EndInit ();

De mogelijke types performance counters kan je hieronder raadplegen. •

Active threads: de beschikbare threads in de threadpool.

•

In use threads: de threads die momenteel bezig zijn met een functie uit te voeren.

•

Overhead threads: de threads die actief zijn, maar niet in gebruik.

•

% overhead threads: overhead threads procentueel voorgesteld.

•

% overhead threads base: actieve threads die niet gebruikt zijn, procentueel voorgesteld.

•

Work Items: het aantal afgewerkte + niet afgewerkte functies.

•

Work Items in queue: het aantal niet afgewerkte functies.

•

Work Items processed: het aantal afgewerkte functies.

•

Work Items queued/sec: het aantal gegenereerde functies per seconde.

•

Work Items processed/sec: het aantal uitgevoerde functies per seconde.

Avg. Work Item process time/sec: de gemiddelde tijd per seconde die nodig is om een functie uit te voeren


Threading in Londen In het kader van ons threading onderzoek is Brecht Kets naar een bijeenkomst van Intel geweest te Londen. Volgend onderdeel is hiervan een verslag. Locatie Radisson Edwardian Grafton Hotel 130 Tottenham Court Road, London W1T 5AY Programma 11:00-11:10

Welcome and introductions - Martin Strobel

11:10-11:30

Why does Intel care about software - Edmund Preis

11:30-12:30 Reinders

Multicore Opportunity: Developers in transition - James

12:30-13:00

Lunch

13:00-13:30

Intel Software: Optimizing application - James Reinders

performance 13:30-14:30

Best practices: Customer design wins - Shobhan Jha

14:30-15:30

Scaling threading for multicore methodology Heinz Bast

demonstration 15:30-16:30

Q&A - James Reinders

Why does Intel care about software De drie pijlers Creatie Ten eerste ontwikkelde Intel performante thread-safe bibliotheken om real-time geoptimaliseerde code te ontwikkelen. Bijvoorbeeld: Intel Performance libraries, Intel Math Kernel Library en de Intel Cluster Tools. Testen Op de tweede plaats werden Tools ontwikkeld om problemen met bestaande applicaties op te lossen. Enkele voorbeelden van die applicaties zijn: VTune performance analysers, Intel Thread checker en Intel Thread Profiler. Optimalisatie Ten slotte ontwikkelde men Tools om uw applicatie te optimaliseren voor het Intel platform. De Intel Compilers maken deel uit van deze groep.


Multithreading, Testcases Oracle Oracle maakt gebruik van VTune performance Analyzer, C++ compiler (Linux en Windows) om hun database-server optimaal te laten functioneren. Volgens Intel bracht het gebruik van de Intel Compiler een performantiewinst met zich mee. CERN CERN maakt ook gebruik van de Intel Compiler en men heeft ook onderzoek naar de performance verricht. Blijkbaar was hun code, die werd gecompileerd met de Intel compiler, een dertig procent sneller dan wanneer deze werd gecompileerd door GCC 3.2. Kaspersky Door gebruik te maken van VTune en de Intel Compilers beweert Kaspersky dat dit een zesenzestig procent snelheidswinst voor hun software teweeg bracht. Noteer wel dat er andere tools bestaan dan VTune om software te analyseren en dat deze resultaten ook op geen enkele manier kunnen geverifieerd worden. Waarom multithreading Door het feit dat processors nu meer en meer multicore worden, is multithreaded software belangrijk! Zonder multithreading kan je geen optimaal gebruik maken van deze technologie. Momenteel is er nog te weinig ondersteuning en te veel onwetendheid over multithreading. Intel hoopt daar verandering in te brengen door lezingen te geven en tools te ontwikkelen die het leven van een ontwikkelaar vergemakkelijken. Je kan dan wel denken dat dit een nobel doel is, maar als deze stap niet wordt genomen kunnen ze de weg van multicore niet inslaan. Enkele cijfers die de toekomstplannen van Intel tonen: 2005

2006

2007

Desktop

Begin

> 70%

> 90%

Mobile

Begin

> 70%

> 90%

Server

Begin

> 85%

~100%

Multicore opportunity: Developers in transition Algemeen Aangezien de toekomst meer een meer multicore processors zal bieden, moeten ontwikkelaars zich daaraan aanpassen. Er zijn meerdere redenen die Intel dwingen deze weg in te slaan. Indien mogelijk, gingen ze door met de netburst-architectuur tot ze aan 10 Ghz kwamen. Maar stroomverbruik en de concurrentie staken daar een stokje voor! De beperking van stroomverbruik kwam grotendeels door de notebook-markt.


Niets doen Zelfs indien men niets verandert aan de manier waarop applicaties ontwikkeld worden, zou de stap naar multicore nog altijd voordelen opleveren. Zo zouden twee single-threaded applicaties toch gebruik kunnen maken van verschillende CPU’s. Ook achtergrondprocessen zoals anti-virus software kan voordelen halen uit multicore. Het potentieel Threading maakt het nog altijd mogelijk om het volle potentieel van een multicore-systeem te benutten. De weg naar multithreading wordt nu pas bewandeld. Voor veel bedrijven is dit nog altijd een stap in het ongewisse. Meer en meer fabrikanten leveren tools om het makkelijker te maken uw applicaties dit multicore-potentieel volop te laten benutten. Naast native threads bestaan er ook threaded libraries, die een groot deel van het werk voor u doen. Het is ook mogelijk de compiler het werk voor u te laten doen, namelijk door compiler generated threads. Voordelen Betere responstijden. Dit is een groot voordeel voor de user interface waar het gebruik van ‘de zandloper’ kan vermeden worden. Tevens zal de laadtijd verminderen. Hogere throughput. Dit kan op meerdere vlakken nut hebben, zoals bij database-servers waar queries tegelijk afgehandeld kunnen worden, of zoals support voor meer simultane gebruikers. Gebruikerservaring. Door de mogelijkheid om te multitasken is de gebruikerservaring al veel verbeterd. In de toekomst kan dit er nog meer op vooruitgaan. Intel Software: Optimizing application performance Algemeen Deze sessie was een overzicht van alle Intel software. Er kwamen veel nutteloze onderwerpen aan bod, maar hieronder bespreek ik toch enkele interessante. VTune Vtune performance analyser is een tool die door Intel ontwikkeld werd om de performance van uw applicatie te bekijken. De mogelijkheid bestaat er bijvoorbeeld in om te zien wat een bepaalde thread aan het doen is, en nog belangrijker, hoe lang hij niets doet. OpenMP OpenMP is een API die het programmeren voor meerdere processoren makkelijker maakt. De MP in OpenMP staat voor Multi Processing. OpenMP werkt zowel met c++ als met Fortran. Om een programma goed gebruik te laten maken van meerdere processoren, is het essentieel dat er delen van het programma parallel uitgevoerd kunnen worden. Dit wordt gerealiseerd door middel van threads. OpenMP is verschillend van andere thread-libraries. Want daar waar de andere bibliotheken elke taak op een andere thread uitvoeren,


wordt een taak met behulp van OpenMP over meerdere threads uitgevoerd. De programmeur geeft aan welke delen van zijn programma hij multithreaded wil maken, door middel van compileerexpressies. OpenMP kiest dan tijdens runtime hoeveel threads hij wenst aan te maken. #pragma omp parallel for for(int i = 0;i < 100000;i++) { // Doe iets }

MPI De Intel MPI bibliotheek is een bibliotheek die ontworpen is om multithreaded programmeren eenvoudiger te maken. MPI maakt deel uit van Intel cluster tools. Best practices: Customer design wins Tijdens deze sessie werden enkele case studies van Intel besproken. Daar ik een non-disclosure agreement moest ondertekenen kan ik hier niet verder op ingaan. Scaling threading for multicore methodology demonstration Demonstratie van VTune in samenwerking met OpenMP.


Public Relations Een project als Sheridan kan niet zonder reclame, presentaties en een mooie grafische vormgeving. Er is deze stage zelfs heel wat tijd gekropen in het verzinnen van mooie slogans, namen voor projectonderdelen, het maken van schema's die duidelijk zijn voor leken en schema's voor de meer technisch aangelegde mensen. Het is zelfs zover gegaan dat we als promotiemateriaal een strip hebben gemaakt waarin de volledige workflow en visie achter Sheridan verwoven zit.

Vormgeving De naam Sheridan is ontstaan na een brainstorming van alle teamleden. Na een selectie van een tien tal namen is Sheridan er als overwinnaar uitgekomen.

Figuur 47 : Logo Sheridan


Stripverhaal

Figuur 48 : Stripverhaal over Sheridan


Promotie affiche

Figuur 49 : Promotie affiche


Brochure

Figuur 50 : Binnenkant brochure


Figuur 51 : Buitenkant brochure


Database Optimalitaties MySQL Algemeen MySQL is een opensource relationele database (RDB), die gebruik maakt van SQL. Het MySQLsoftwarepakket bestaat onder meer uit: een serverprogramma en een verzameling van clientprogramma’s. Het serverprogramma heet mysqld. Hierbij staat de d voor ‘daemon’, de Unix- of Linux-term voor een proces dat netwerkconnecties accepteert. De clientprogramma’s zijn onder andere MySQL en MySQLdump. Met deze programma’s kan met de server gecommuniceerd worden. Versies Dit jaar hebben werd er vooral getest met MySQL 4.0. Dit omdat we deze versie het best beheersen. Nu zijn er reeds twee stabiele versies na 4.0, namelijk 4.1 en 5.0. Deze laatstgenoemde versie heeft dan wel meer opties dan voorgaande versies (zoals Stored Procedures, Triggers, Views, enz.). MySQL 5.1 is reeds in bèta, maar de resultaten van onze tests met deze versie waren beneden alle peil. Maar nogmaals, deze versie is momenteel nog een bètaversie.


Installatie Onder Gentoo De installatie van MySQL onder Gentoo is redelijk eenvoudig. Dit gaat via het commando: “emerge –av=dev-db/mysql-4.0.25-r2”.

Zoals je kan zien kan je een versienummer meegeven via dit commando. De mogelijke versies kan je raadplegen op http://packages.gentoo.org/search/?sstring=mysql. Onder Suse Onder Suse wordt de installatie van MySQL geregeld via YAST. Typ YAST in een console of open YAST via de GUI. Ga vervolgens naar “Install/Remove Software”. Hier kan je zoeken naar MySQL. Hou er rekening mee dat je niet enkel MySQL moet selecteren, maar ook mysql-max, anders zal het gebruik van InnoDB onmogelijk zijn. Om ervoor te zorgen dat MySQL automatisch opstart kan je het volgende commando invoeren: chkconfig –a mysql

RPM Package Manager Er kan ook geïnstalleerd worden via een rpm package, die afgehaald kan worden van de MySQL website. Installeren kan als volgt: Rpm –i package.rpm

Basisrechten instellen Na de installatie stel je best onmiddellijk een basiswachtwoord in voor de root gebruiker. Dit om toegang voor onbevoegden onmogelijk te maken. Dit kan via volgend commando: “mysqladmin -u root password 'eindwerk'”


Database terugplaatsen De database terugplaatsen kan op verschillende manieren, via een sql-backup of via datafiles. Beide methodes worden hieronder beschreven. Merk op, een restore via datafiles werkt niet altijd, de methode via een sql-backup is een aanrader. Het nadeel van deze methode is wel dat het lang kan duren als er geen SCSI of SAS schijven aanwezig zijn (tot 6 uur). SQL-backup Open een MySQL client en log in. mysql –p

Vervolgens moet de database aangemaakt worden. mysql> create database benchdb; mysql> use benchdb;

Nu kunnen we de data importeren. mysql> source backup.sql;

Indien je nog niet ingelogd bent in de MySQL-client, en de database benchdb bestaat al, dan kan je ook de data importeren op volgende manier: mysql -u root -p benchdb < backup.sql

Datafiles Je kan natuurlijk ook de datafiles van een mysql server kopiëren en terugzetten. Merk wel op dat de datafiles versiespecifiek zijn. De eerste stap die moet ondernomen worden is de oude datafiles verwijderen. Let wel op dat de MySQL-server gestopt is. # rm –r /var/lib/mysql


Vervolgens kunnen we de datafiles terugplaatsen en de eigenaar terug instellen. # tar zxvf /mnt/cdrom/data/mysql-data-4.0.x.tar.gz -C /var/lib/mysql # mv /var/lib/mysql-data-4.0.x /var/lib/mysql # chown –R mysql:mysql /var/lib/mysql

Externe toegang Om externe toegang mogelijk te maken via de verschillende ip-adressen die mogelijks aanwezig zijn op de server zijn er enkele aanpassingen nodig. Eerst moeten we (alle) gebruikers toegang geven om te connecteren met de MySQLserver. mysql> grant all privileges on *.* to root@’%’ identified by ‘password’; mysql> flush privileges; mysql> set password for root@'%' = OLD_PASSWORD('eindwerk');

Het ‘password’ moet je vervangen door het gewenste paswoord. Indien u geen paswoord wenst te gebruiken, kan u ‘identified by password’ weglaten. In de globale config-file (/etc/mysql/my.cnf of /etc /my.cnf ) moet de volgende waarde nog aangepast worden: bind-address = 0.0.0.0

Dit om ervoor te zorgen dat de MySQL-server naar alle ip-adressen luistert.


Engines Algemeen Een van de sterktes van MySQL is dat het de mogelijkheid biedt om te kiezen welke storage engine je wil gebruiken, afhankelijk van je behoeftes. Hier zal ik enkel onze gebruikte engines beschrijven, namelijk InnoDB en MyISAM. MyISAM MyISAM is de default engine van MySQL. Elke MyISAM-tabel is opgeslaan op het schijfsysteem in zijn eigen map en deze map bevat 3 bestanden: een .frmbestand, die het tabelformaat opslaat, een .myd-bestand (MYData), die de data bevat, een een .myi-bestand, die de indexen opslaat. MyISAM maakt gebruik van een table-locking mechanisme om reads en writes te coördineren. Een nadeel hiervan is dat je af en toe het ‘OPTIMIZE TABLE’-commando moet uitvoeren om de verloren ruimte te recupereren. MyISAM dient vooral te gebruiken voor snelle read-operaties. InnoDB InnoDB is een engine voor MySQL die transacties ondersteund, wat MyISAM niet doet. Het heeft commit, rollback en crash-recovery mogelijkheden. InnoDB lockt op een rij-level, en heeft een Oracle-stijl lock voor read operaties (shared lock). Dit zorgt ervoor dat MySQL bij een hogere concurrency beter presteert. In tegenstelling tot MyISAM beschikt InnoDB ook over foreign-keys. Onder windows zorgt de binary-installer ervoor dat InnoDB de default engine is. InnoDB dient vooral gebruikt te worden voor grote databases die hoge performantie nodig hebben.


Optimalisaties Algemeen MySQL optimalisaties is geen gemakkelijk onderwerp. Er is geen standaard waarde die je kan instellen voor MySQL om de performance drastisch te verhogen. Er is een kennis van de werking van MySQL en de huidige hardware nodig. De opbouw van de database, de gebruikte storage-engine en het optimaliseren van de queries zijn enorm belangrijk. Toch zal ik je in de volgende alinea’s je de kennis proberen mee te geven om de MySQL-server en de database zo te configureren dat je toch een performance winst krijgt. Indices Een index is een mechanisme die maakt dat MySQL of een andere database een manier heeft om een waarde te zoeken zonder de tabel rij per rij te hoeven doorlopen. Indices zorgen ervoor dat MySQL een manier heeft om rijen als het ware te sorteren alvorens te beginnen zoeken, wat performance heel veel ten goede komt. Je kan het een beetje vergelijken met een telefoonboek. Als je de naam Kets moet zoeken, dan weet je dat je moet beginnen bij de K, en niet bij de A. Om te weten op welke kolommen je een index moet leggen moet je weten hoe MySQL je queries parst. Dit kan je te weten komen aan de hand van het EXPLAIN-statement. Je kan ook een idee krijgen welke queries aandacht nodig hebben via het longquery log. Dit kan je activeren door in de config-file de variabele long_query_time te initialiseren (vb. long_query_time = 2 --long –log –format). Merk op dat je de variabele long_query_time niet hoeft te initialiseren indien select_full_join gelijk is aan 0 (je kan dit opvragen via het commando ‘SHOW STATUS’).


Figuur 52 : MySQL Administrator

Explain Wanneer je een query voorafgegaan door de term ‘EXPLAIN’ uitvoert zal de optimizer u informatie over het executieplan van de query. Via dit commando kan je te weten komen waar je indices moet toevoegen om het uitvoeren van de desbetreffende query sneller te doen verlopen. Het explain commando geeft voor elke tabel die door de query aangesproken wordt een rij terug. In het veld “possible_keys” vind je de mogelijke keys terug. Meer info over het explainstatement kan gevonden worden in de MySQL Reference Manual.


Figuur 53 : MySQL Browser


Config-waarden key_buffer_size De key buffer is een buffer die gebruikt wordt om indexen te beheren. Deze waarde is voor alle threads samen. Dit is het geheugen die MySQL kan alloceren om index blocks in te cachen. Een goede waarde voor deze variabele is tussen de 256M en 1G. Om deze waarde exact te optimaliseren is er een beetje trial and error nodig. Via het commando “Show status” moeten volgende waarden aan deze criteria voldoen: key_read / key_read_requests moet kleiner zijn dan 0,01 key_write / key_write_requests moet kleiner zijn dan 1 Indien dit niet het geval is moet je de key_buffer_size verhogen. Let wel op de beperkingen van het RAM geheugen. table_cache Dit is het aantal tabellen dat maximum tegelijk mag geopend worden per connectie. Dus als je 5 connecties hebt die elk 10 (dezelfde) tabellen ondervragen, dan heb je 50 open tabellen (.frm files). Hiervoor moet je de basis begrijpen van hoe MyISAM een tabel opent. Wanneer we een tabel ondervragen wordt de .frm file geopend, wordt de content gecached en de file onmiddellijk terug afgesloten. De index file (.myi) wordt geopend en gedeeld door alle connecties. Het data-bestand (.myd) wordt geopend door elke connectie die deze tabel aanspreekt. Table_cache kan er dus voor zorgen dat de .frm files minder vaak geopend worden. Deze variabele heeft voornamelijk zijn effect wanneer je gebruikt maakt van de MyISAM engine. Je kan controleren of deze waarde hoog genoeg is door volgende waarden te raadplegen via ‘show status’. Indien de waarde opened_tables veel hoger is dan open_tables verhoog je best de table_cache. Nogmaals, indien je gebruik maakt van MyISAM is deze waarde heel belangrijk. sort_buffer_size Telkens een thread een sort moet uitvoeren wordt een buffer van deze grootte gealloceerd. Dit zorgt er voornamelijk voor dat ‘Order by’ en ‘Group by’ operaties sneller worden uitgevoerd. read_buffer_size Dit is de grootte van de buffer die elke thread gebruikt voor een scan door een tabel. Deze waarde is voornamelijk goed voor MyISAM. read_rnd_buffer_size Na het uitvoeren van een sort, wanneer er rijen uitgelezen worden, wordt er per thread een buffer van deze grootte aangemaakt. Wanneer je veel ‘join’ en ‘group


by’ statements hebt kan je overwegen om deze waarde te verhogen. Let erop dat je nog geheugen overlaat voor andere applicaties, aangezien deze waarde per connectie is. Een regel voor deze waarde is 1kb instellen voor elke MB geheugen, dus als je een systeem hebt met 8GB geheugen, stel je deze waarde in op 8MB. query_cache MySQL heeft de mogelijkheid om queries te cachen, om zo de uitvoersnelheid te verhogen. Aangezien het randomizen van een test nooit 100% is, kunnen we deze waarde het best uitschakelen om realistische resultaten te verkrijgen. Dit kan door volgende waarden in te stellen: query_cache_size = 0 query_cache_limit = 0 query_cache_type = 0 max_connections Deze variabele spreekt voor zichtzelf. Het maximum aantal connecties toegelaten op de MySQL-server. thread_concurrency Deze waarde verteld MySQL hoeveel threads hij tegelijk mag openen. Een vuistregel is deze waarde in te stellen op het dubbel van uw aantal processors. innodb_buffer_pool_size Dit is de buffer die gebruikt wordt voor InnoDB tabellen, om indexen en data te cachen. Hoe groter deze waarde, hoe minder disk IO. innodb_additional_mem_pool_size Dit is de buffer die InnoDB gebruikt om Data Dictionary informatie en andere datastructuren op te slaan. Hoe meer tabellen je database telt, hoe hoger deze waarde moet zijn. innodb_thread_concurrency Deze waarde stelt het maximum aantal InnoDB threads in het OS voor. In de verschillende MySQL versies heeft deze waarde wijzigingen ondergaan. Wanneer je in MySQL 5.0.19 + deze waarde aan 0 gelijkstelt, wil dit zeggen een ongelimiteerd aantal threads binnen InnoDB. In versies onder MySQL 5.0.8 moest je deze waarde hoger dan 500 instellen om hetzelfde resultaat te bekomen. Met deze waarde experimenteer je best eens, aangezien ze afhankelijk is van de versies. Wij hebben betere resultaten ondervonden als deze waarde laag ingesteld was, zoals op 32.


Geheugen bemerking Zorg ervoor dat de volgende bewerking nooit hoger wordt dan het beschikbaar geheugen: Geheugen = key_buffer+ (sort_buffer_size + read_buffer_size) * max_connections


Solaris Optimalisaties Wanneer je volgende waarden aanpast in /etc/system zou dit volgens sun heel wat performantiewinst betekenen: set set set set set set set set set set set

pcie:pcie_aer_ce_mask=0x1 segkmem_lpsize=0x400000 ip:ip_squeue_bind = 0 ip:ip_squeue_fanout = 1 ipge:ipge_tx_syncq=1 ipge:ipge_taskq_disable = 0 ipge:ipge_tx_ring_size = 2048 ipge:ipge_srv_fifo_depth = 2048 ipge:ipge_bcopy_thresh = 512 ipge:ipge_dvma_thresh = 1 consistent_coloring=2

Uit onze tests bleek echter dat dit negatieve resulaten had. Deze instellingen hangen dan ook af van load tot load en dienen getest te worden. Solaris Priocntl Op Solaris kan je de scheduler aanpassen van een default- naar een fixedpriority. In sommige gevallen kan dit een verhoging van de performantie betekenen, in andere gevallen kan dit het omgekeerde betekenen. De scheduler aanpassen kan via volgende methode: #priocntl -s -c FX

Waar pid staat voor het process-id. Renice Zowel onder Linux als onder Solaris kan je een proces “renicen”. Dit betekend dat je het process een hogere priority heeft. Indien je dit toepast op een server waar geen andere noemenswaardige software op draait zal dit positieve gevolgen hebben als je deze waarde op vb. -15 instelt. Renicen kan gebeuren wanneer je in het ‘top’-programma zit op ‘r’ te drukken. Geef vervolgens het process-id in gevolgd door de waarde (kleiner is hoger, dus -15 is goed, -20 is het maximum).


Schaling Algemeen Van single core naar dual core schaalt MySQL redelijk, dit levert een 27% resultaatswinst op. Wanneer men echter van dual naar quad gaat verschijnt een prestatieverlies van 27% op. Wanneer men meer cores toevoegt gaat dat verschijnsel verder. Dit is enkel op Linux. Op Solaris zijn de resultaten in het algemeen slechter, maar is de schaling wel positief. Het probleem is bekend bij MySQL en er zijn zelfs al bugreports over (http://bugs.mysql.com/bug.php?id=15815). Het zou een probleem zijn met mutexes. Mutexes Mutexes is een methode / algoritme dat gebruikt wordt om ervoor te zorgen dat 2 threads (de parent-thread inclusief) niet proberen eenzelfde resource tegelijk aan te spreken. Dit kan zowel het geheugen als een bepaalde file zijn. Wanneer een programma gestart wordt, wordt er een mutex met een unieke naam aangemaakt. Vanaf dit punt, wanneer een bepaalde thread een resource nodig heeft, moet het deze mutex locken zolang het de resource gebruikt. Bemerkingen Indien je van plan bent een database te benchmarken, dan voor je best voor de test het ‘OPTIMIZE TABLE’-commando uit. Dit voor elke tabel in de database. Meer info over MySQL kan gevonden worden op http://www.mysql.com.

Resultaten Wat waren nu de concrete resultaten van alle MySQL tweaks? We overlopen alle resultaten in chronologische volgorde, in het begin van de stage installeerden we MySQL, en met dbbench2004 haalden we toen een goeie 120 queries/sec. op de SunFire. En een 400 QPS op onze referentiemachine. De optimalisaties waar wij ons op baseerden waren die die we vonden in het Anandtech-artikel van verleden jaar.

Figuur 54 : Eerste resultaten


Dit is dus niet zo spectaculair, maar beterschap was onderweg, de eerste goeie stap in die richting was Heimdall, deze door Brecht Kets ontwikkelde beta-tool van Sheridan doet zijn werk op een gelijkaardige manier als dbbench, maar springt veel beter om met de resources van de client. En doet de tijd- en andere metingen veel nauwkeuriger. Wat natuurlijk de grote sprong vooruit was, was ons contact bij MySQL: Peter Zaitsev, deze hoofdprogrammeur van MySQL is gestationeerd in Seattle en ons hele team (Ben afgezonderd) ging op bezoek in Seattle en had een gespreken met de MySQL-guru. Hij gaf ons véél nuttige tips, en daarmee gingen wij aan het werk, de vruchten van die tips hebt u zonet in de voorgaande alinea’s gelezen. Hier het ultieme resultaat:

Quad Core - Dual CPU 1200 Woodcrest

Queries/Sec

1000 HP DL585

800 MSI K2-102A2M (2.2GHz) SuperMicro (Dual CPU-HT) Dikke MSI

600 400 200 0 1

2

4

5

8

10 20 25 50 100

Concurrency

Black Dual Xeon (Dual CPU-HT) MSI K2-102A2M (2.4GHz)

Figuur 55 : Quad Core - Dual CPU

Uiteraard bekeken we ook de scaling: als we van 1 cpu met 1 kern overstappen naar 2 cpu’s met 1 kern zagen we een flinke vooruitgang. Als we van 1 cpu met 1 kern overstappen naar 1 cpu met 2 kernen zagen we een grotere vooruitgang. Doch vanaf het moment dat we overstappen naar 4 kernen zagen we tot 40% negatieve schaling. Ook HyperThreading heeft negatieve schaling.


Dual Core - Single CPU

Queries/Sec

1200 1000

Woodcrest

800

HP DL585

600

MSI K2-102A2M (2.2GHz) SuperMicro (Single CPU-HT) Dikke MSI

400 200 0 1

2

4

5

8

10 20 25 50 100

Concurrency Figuur 56 : Dual Core - Single CPU

Black Dual Xeon (Single CPU-HT) MSI K2-102A2M


Figuur 57 : MySQL 5.0.21 Queries / s

Hier spelen we enkele machines uit tegen de SunFire die zoals bekend 8 cores heeft. Aangezien iedere kern slechts op 1000MHz geklokt staat rendeert deze UltraSparc slechts vanaf 20-30 concurrent threads. Als de alle threads in werking zijn ziet dit er ongeveer zo uit:

Figuur 58 : CPU Graph


PostGreSQL Algemeen PostgreSQL is een vrije relationele databaseserver, uitgegeven onder de flexibele BSD-licentie. Net als andere OpenSource projecten wordt PostgreSQL niet beheerd door één enkel bedrijf, maar steunt het op een wereldwijde gemeenschap van ontwikkelaars en bedrijven. PostgreSQL wordt officeel uitgesproken als "post-gress-Q-L", maar veel gebruikers korten het af tot "postgres". PostgreSQL is minder bekend dan MySQL en daarom ook vaak minder ondersteund. Waar MySQL de nadruk legt op prestaties legt PostgreSQL de nadruk op stabiliteit. Een uniek aspect aan PostgreSQL is dat het voor elke connectie een nieuw proces aanmaakt, waar andere databases slechts een nieuwe thread aanmaken. PostgreSQL gebruik je best op Linux of Solaris, aangezien deze ontwikkeld is voor een UNIX-systeem. Wanneer je deze op Windows installeert wordt er een extra laag geïnstalleerd zodat PostgreSQL zou kunnen werken als een service. Versies Dit jaar hebben werd er vooral getest met PostgreSQL 8.0.7, daar dit de laatste stabiele versie was bij het starten van de stage. Op het moment van dit schrijven is versie 8.1.4 reeds beschikbaar.


Installatie RPM Package Manager Er kan geïnstalleerd worden via een rpm package, die afgehaald kan worden van de PostgreSQL website. Installeren kan als volgt: Rpm –i package.rpm

Via compilatie De installatie van PostgreSQL moet gebeuren via compilatie van de code. Eerst extracten we de installatiebestanden naar een tijdelijke map, vb. /tmp. De installatiebestanden kunnen gedownload worden van de website www.postgresql.org. # tar jxvf /mnt/cdrom/PostGreSQL-installs/postgresql-8.0.7.tar.bz2 -C /tmp/ # cd /tmp/postgresql-8.0.7

Het commando "Configure" dient om na te gaan of alles aanwezig is om de mogelijkheid te hebben om te compileren. # ./configure

In normale omstandighedens zouden alle compile-tools moeten geïnstalleerd zijn. Indien niet, kun je ze via YaST eventueel installeren. Nadat je de eventuele tools geïnstalleerd hebt mag je zonder problemen het 'configure' commando opnieuw uitvoeren. Indien alles correct verlopen is moet je iets in de aard van onderstaande afbeelding te zien krijgen.

Figuur 59 : Configuratie PostGreSQL


Nu zijn we klaar voor het compilen zelf: # make && make install

Figuur 60 : Make install PostGreSQL



Nu mag de tijdelijke map eventueel verwijderd worden. # cd && rm -r /tmp/postgresql-8.0.7

Figuur 61 : Delete tempory map

Postgres gebruiker aanmaken De nodige gebruikers aanmaken kan via volgend commando: # groupadd postgres && useradd -G postgres postgres

Database terugplaatsen Nu kunnen we de data-directory aanmaken waar de juiste database reeds in aanwezig is, en de eigenaar correct instellen: # tar xvf /mnt/cdrom/backup/postgresql_backup.tar -C / # chown -R postgres:postgres /var/lib/postgresql


Er moet ook nog een pid-file verwijderd worden: # rm /var/lib/postgresql/data/postmaster.pid

Kernel aanpassingen Nu dienen we ook ook nog enkele kernel aanpassingen maken, namelijk het kernel geheugen (shmmax) vermogen. Indien dit niet gebeurt zal PostgreSQL niet met geoptimaliseerde waarden willen starten. Merk op dat dit niet onder elke Linux-distro nodig is. # echo 4000000000 > /proc/sys/kernel/shmmax

Gebruikers aanmaken We dienen ook nog een root gebruiker aan te maken die kan verbinden met PostGreSQL, dit doen we als postgres-user:


# createuser -P root

Het passwoord zal 2x gevraagd worden, en op de overige 2 vragen mag je 'y' antwoorden.

Server starten Nu kunnen we de server starten onder de postgres gebruiker met het volgende commando: # postmaster &

Willen we hem stoppen, doen we dit terug onder de postgres-user: # pg_ctl stop


Optimalisaties Algemeen PostgreSQL-optimalisaties zijn ons veel minder bekend dan MySQL-optimalisaties Prepared Statements PostGreSQL-optimalisaties zijn ons veel minder bekend dan MySQLoptimalisaties, daar we in PostgreSQL veel minder tijd hebben kunnen stoppen. We hebben ook geen mensen van de industrie om ons bij te staan met PostgreSQL problemen. Prepared statements De grootste optimalisatie voor PostgreSQL in een applicatie waar er 90% reads zijn, is gebruik te maken van prepared statements. Een prepared statement is een server-side object dat kan gebruikt worden voor optimalisaties. Wanneer er een prepared statement wordt uitgevoerd wordt deze geparsed, herschreven en gepland. Wanneer het execute statement wordt uigevoerd, dient de prepared statement slechts uitgevoerd te worden. Dit zorgt ervoor dat wanneer een query meerdere malen wordt uitgevoerd, er slechts eenmaal geparsed, herschreven en gepland wordt in plaats van meerdere malen. Prepared statements worden over een sessie bijgehouden, na de sessie worden deze vernietigd. PREPARE plan_name [ (datatype [, ...] ) ] AS statement

Shared Buffers PostgreSQL wijzigt niet rechtstreeks informatie op de schijf. In plaats daarvan vraagt hij aan om de informatie in de Shared Buffers in te lezen. De postgreSQL backend plaats dan deze informatie in de Shared Buffers. Indien deze buffers te klein zijn zullen de lees-operaties te frequent voorkomen. De default PostgreSQL-configuratie alloceert 64 Shared Buffers. Elke buffer is 8kB groot. Ja kan nu denken dat je al uw beschikbare RAM moet toekennen aan de Shared Buffers, maar dit is een slecht idee, aangezien er dan geen plaats meer is voor de kernel en andere waarden / applicaties. Sort mem Specificeert het aantal intern geheugen dat kan gebruikt worden door sorts vooraleer over te gaan naar tijdelijke tabellen. Deze waarde wordt uitgedrukt in kilobytes en is standaard 512. Deze waarde is per thread. Max connections Het maximum aantal toegelaten connecties. Fsync Booleaanse waarde waarlangs je kan instellen of er onmiddellijk naar de schijf moet geschreven worden of de waarden gebufferd kunnen worden.


Solaris Priocntl Op Solaris kan je de scheduler aanpassen van een default- naar een fixedpriority. In sommige gevallen kan dit een verhoging van de performantie betekenen, in andere gevallen kan dit het omgekeerde betekenen. De scheduler aanpassen kan via volgende methode: #priocntl -s -c FX

Waar pid staat voor het process-id. Renice Zowel onder Linux als onder Solaris kan je een proces “renicen”. Dit betekend dat je het process een hogere priority heeft. Indien je dit toepast op een server waar geen andere noemenswaardige software op draait zal dit positieve gevolgen hebben als je deze waarde op vb. -15 instelt. Renicen kan gebeuren wanneer je in het ‘top’-programma zit op ‘r’ te drukken. Geef vervolgens het process-id in gevolgd door de waarde (kleiner is hoger, dus -15 is goed, -20 is het maximum). Schaling Na onze weinige tests blijkt dat onder onze read-intensive load PostgreSQL ook niet goed schaalt. Hiervoor dient nog meer onderzoek te gebeuren. Resultaten En hier een overzichtje van de concrete resultaten van de PostgreSQL bench. De test die we als eerste keer probeerden was op de SunFire T2000, zoals zichtbaar in deze screenshot was dat niet meteen een onverdeeld succes:


Figuur 62 : Heimdall benchmark

We merken dat we slechts 36 tot 52 queries/sec. haalden en dat was niet meteen zoals verwacht. We zijn toen overgeschakeld op MySQL en pas enkele weken later (toen de resultaten van MySQL er waren) zijn we teruggekeerd op PostgreSQL en dat was wél een succes. We konden de resultaten eerst verdubbelen en later nog eens verdubbelen, op 1 machine haalden we zo zelfs topresultaten tot net boven de 700! De negatieve schaling met MySQL trekt zich ook door naar PostgreSQL, op de referentiemachine is er zelfs 45% snelheidsverlies bij het overschakelen van 2 kernen naar 4. Even alle resultaten op een rijtje:


Figuur 63 : Quad Core - Dual CPU, PostGreSQL

Zoals verwacht komt de Intel Woodcrest machine als beste uit de test. We zien ook meteen het verschil tussen de dikke MSI in Linux en dezelfde machine in Solaris. Alle PostGreSQL-tweaks zijn overal exact hetzelfde, exact dezelfde RPMinstallatie en exact dezelfde configuratiefiles. Dus blijkbaar heeft Solaris andere tuning nodig dan Linux. Ik heb er intussen op zitten zoeken en ik ben er al in geslaagd om kort voor het ter perse gaan van dit document de Solaris-prestaties op te drijven tot boven de 300. Nog steeds niet gelijkaardig aan Linux, maar toch reeds een verdubbeling. Gelijkaardig beeld bij 2 kernen (1cpu):

Ook even verduidelijken in verband met het zicht dat de SuperMicro machine (6014P-32R) wat minder presteert, dit is echter doodnormaal aangezien het hier geen Dual Core betreft maar een Xeon mét HyperThreading.


Conclusies Ben Motmans Het ontwikkelen van Sheridan was niet altijd even eenvoudig. Aangezien dit een vrij uniek en innovatief project is, vergde dit een zekere creativiteit en doorzettingsvermogen. Ook naar samenwerking toe vergde dit project een aantal vaardigheden, aangezien ik verantwoordelijk was voor het coördineren van mijn collega’s. Op dit gebied heb ik enorm veel kennis opgedaan, meer bepaald naar timemanagement in bedrijfssituaties. Een enorme opsteker aan deze stageopdracht, was de interesse van diverse nationale en internationale bedrijven. Dit gaf mij zekerheid dat het een nuttig eindwerk is, en niet zonder meer wordt geklasseerd in een archief. Hetgeen mij gedurende deze stage periode zeker en vast motiveerde en inspireerde. Ook heb ik tijdens deze stage enorm veel bijgeleerd over de interne werking van parsers en compilers, een nuttige en complexe vaardigheid die niet op de schoolbanken wordt aangeleerd, maar toch zeer regelmatig gebruikt wordt in de software industrie.

Ten slotte wil ik nogmaals benadrukken dat deze stageperiode enorm boeiend was, dit dankzij de uitstekende combinatie van innovatief programmeerwerk en de nauwe samenwerking met de industrie.


Brecht Kets In deze stageperiode heb ik niet alleen een grotere bagage aan kennis en vaardigheden opgepikt, maar ook veel bijgeleerd over mezelf. Dit vooral op vlak van toekomstperspectieven en ambities. Zo heb ik ervaren dat dit soort onderzoekswerk me meer ligt dan bijvoorbeeld een ‘9 tot 5 job’ waar ik elke dag hetzelfde moet doen. Het werkt inspirerend om de basis van de nieuwste technologieën te kunnen onderzoeken en applicaties te schrijven die uniek zijn. De interesse van de grote buitenlandse bedrijven, zoals bijvoorbeeld Intel USA, is niet iets dat je in zomaar elke stage of eindwerk ziet. Naar samenwerking toe heb ik ervaren dat ons team goed fungeerde. Er deden zich weinig conflicten voor en onze samenwerking verliep vrij goed omdat iedereen gemotiveerd was en bleef. Doorheen deze stage heb ik ook heel wat meer opgestoken over programmeerkennis en databasekennis. Zeker op vlak van databases heb ik veel bijgeleerd over optimalisaties. En je krijgt natuurlijk ook niet elke dag de kans om met Peter Zaitsev, hoofd van de MySQL performance-group, samen te werken! Ik ben ook heel wat technische moeilijkheden tegengekomen in dit project, aangezien dit geen standaard project was maar toch wel een vrij complexe aangelegenheid. Ik denk onmiddellijk aan het zo flexibel mogelijk maken van Sheridan en aan het threading-mechanisme. Bij het ontwikkelen van de flexibiliteit hebben we beroep gedaan op de kennis van de ontwikkelaars van SharpDevelop. Aan de ontwikkeling van het threading-mechanisme werd ook heel wat tijd besteed. Ik heb heel wat boeken over threading doorgeworsteld en heel wat voorbeelden bekeken. Naar de toekomst toe vind ik het zeker interessant om dit project verder te zetten. Niet alleen om internationale naambekendheid te behouden, maar ook om de samenwerking met de industrie verder te zetten. Ik geloof dat we hier aan de voet staan van een nieuw Labo Lemcko.


Sam Van Broeck Tijdens deze stage heb ik op verschillende gebieden enorm enorm veel bijgeleerd. Niet enkel op technisch gebied, maar ook op tijdsplanning, Public Relations en communicatievaardigheden. Gezien de grote variateit van bezigheden heb ik mij geen seconde verveeld, in tegendeel. Het was werken, werken en nog eens werken. Mijn multimedia kennis is ook zeer goed van pas gekomen. Ik ben verantwoordelijke voor al het grafische gebeuren omtrent het PWO project "Server Sizing", alsook de eindlayout van Sheridan. Technisch heb ik een veel beter inzicht gekregen in het "echte" object georienteerd programmeren. Interfaces, services, abstracte klasses, ze vlogen de laatste weken rond mijn oren. Nu besef ik ook dat applicatie design niet echt de meeste simpele opdracht is dat er bestaat. Je moet aan alles denken, alles voorzien en zelfs als je het niet voorziet, moet het zo geschreven zijn dat het er mee kan ingeplugd worden. Wat ik ook enorm apprecieerde is de enorme interesse van de industrie. Zo hebben we kunnen samenwerken met Peter Zaitsev, de MySQL guru. Peter hebben we zelfs real-life ontmoet tijdens een lunch in Seattle. Ook de interesse van Intel, D&N en Microsoft deden enorm deugd. Eindelijk eens een werk dat niet verdwijnt in één of andere archiefkast en waar nog eens iets nuttigs mee gebeurd. Alhoewel het project zelf niet nieuw is van dit jaar, staan wij met onze nieuwe innovatie tool Sheridan toch aan de wieg van een nieuw, leerrijk bench-tijdperk. Waar ik wel van verschiet is dat er redelijk wat tegenstand bestaat omtrent nieuwe projecten van MCT studenten. Mensen overtuigen dat een innovatief project als dit enkel maar in het voordeel van de hogeschool kan zijn is niet zo gemakkelijk…


Lijst met afbeeldingen Figuur 4 : DBconn 2004 38 Figuur 5 : source code uit DBconn 2004

39

Figuur 6 : Random queries in DBBench 2004 39 Figuur 7 : Geen uitbreidbaarheid in DBconn 2004 40 Figuur 8 : Screenshot DB Bench 2005 42 Figuur 9 : Screenshot DB Bench 2005 42 Figuur 10 : Screenshot Heimdall

44

Figuur 11 : Restoren van MySql database

46

Figuur 12 : Controle installatie PostGreSQL 48 Figuur 13 : Configureren van PostGreSQL

49

Figuur 14 : Compileren van PostGreSQL op Linux machine

50

Figuur 15 : Verloop compileer actie van PostGreSQL op Linux machine Figuur 16 : Nieuwe Solution aanmaken

57

Figuur 17 : Nieuw project aanmaken 57 Figuur 18 : Een database provider kiezen

58

Figuur 19 : Connectie gegevens instellen

59

Figuur 20 : Nieuw item toevoegen

60

Figuur 21 : Importeren van eigen log file

60

Figuur 22 : Importatie via Plain Text 61 Figuur 23 : Preview log file

62

Figuur 24 : Aanpassing via Queryscript Figuur 25 : Randomizing instellen Figuur 26 : De Object Pool

63

64

Figuur 27 : Kies type benchmark

64

Figuur 28 : Compile info 65 Figuur 29 : Een Sheridan Benchmark 66 Figuur 30 : Query Editor 67

63

50



67

Figuur 32 : Logviewer Sheridan 68 Figuur 33 : Structurele voorstelling van Sheridan Figuur 34 : Screenshot addin manager Figuur 35 : Solution Explorer

73

Figuur 36 : Panels en Views

81

Figuur 37 : Logviewer

82

Figuur 38 : Solution Panel

82

Figuur 39 : Welcome page

83

Figuur 40 : Bugzilla

69

84

Figuur 41 : Custom Error page 84 Figuur 42 : Database Schema

85

Figuur 43 : ANTLR 92 Figuur 44 : External Tools

93

Figuur 45 : Instellen ANTLR

94

Figuur 46 : Performance monitor Figuur 47 : Logo Sheridan

116

129

Figuur 48 : Stripverhaal over Sheridan Figuur 49 : Promotie affiche

131

Figuur 50 : Binnenkant brochure

132

Figuur 51 : Buitenkant brochure

133

Figuur 52 : MySQL Administrator

140

Figuur 53 : MySQL Browser

141

Figuur 54 : Eerste resultaten

146

Figuur 55 : Quad Core - Dual CPU

147

Figuur 56 : Dual Core - Single CPU

148

Figuur 57 : MySQL 5.0.21 Queries / s 149 Figuur 58 : CPU Graph

149

130

68


Figuur 59 : Configuratie PostGreSQL 151 Figuur 60 : Make install PostGreSQL

152

Figuur 61 : Delete tempory map

154

Figuur 62 : Heimdall benchmark

159

Figuur 63 : Quad Core - Dual CPU, PostGreSQL

160


Bijlage Verslagen Ben Motmans Projectweken – week 1 Version control system opzetten (SVN) Dynamic Code Benchmark: performance vergelijking tussen dynamic generated code Vergelijking maken tussen unit testing frameworks Logging framework voor Sheridan uitzoeken Opzetten van Sheridan.Database module en publieke API bedenken ConnectionPool Implementaties voor MS Sql Server, MySql, Oracle, Sybase, PostgreSql en DB2 Projectweken – week 2 Aanmaken van Sheridan.AssemblyGenerator project (eigen manier van dynamisch code genereren) Ondersteuning voor meerdere compiler backends Implementeren van object model vergelijkbaar met C# Eerst gewerkt met een wrapper rond CodeDom, maar uiteindelijk overgestapt op een wrapper direct rond de C# compiler (meer flexibiliteit) Projectweken – week 3 Sheridan.AssemblyGenerator opnemen in de Dynamic Code Benchmark test Sheridan.Core: Implementatie van logging service gebaseerd op log4net Overleg over parsers Het nut ervan in Sheridan uitwerken Sql:1999 overzicht maken Keuze maken van parser generator (Antlr) Aanmaken van Sql:1999 Lexer Beginselen van Sql:1999 Parser Docking framework voor de Gui componenten van Sheridan (DockPanelSuite) Addin manager


Projectweken – week 4 Sql Editor control met ondersteuning voor real-time parsing Gui dispatcher als hulpmiddel voor multi-threaded gui operaties Addin files gebaseerd op Sharpdevelop addin model Connection Manager service + paneel Stage – week 1 (13 maart – 17 maart) LogViewer om real-time error boodschappen op te vangen Herstructurering van Sheridan Settings dialoog + uitbreidbaar maken Gui component voor het valideren van invul formulieren Update tool: ondersteuning voor updates en het aanmaken van update servers Project based design Project/ProjectItems voor het opslaan van informatie Uitbreidbaar via addins Wizard om nieuwe database connecties aan te maken TreeView ontwerpen die in staat is via addins informatie toe te voegen Recent project service Stage – week 2 (20 maart – 24 maart) Refactoring compleet aanpassen van interne structuur en naamgeving van Sheridan zodat we een consistente naamgeving bekomen Opkuisen van dubbele of overbodige code Uitzoeken van NDoc versie die ondersteuning heeft voor .NET 2.0 Entity Relationship diagram (grafische voorstelling van tabellen en constraints) Stage – week 3 (27 maart – 31 maart) Taakverdeling Leren van de ANTLR syntax voor lexers, parsers en tree parsers Opzoeken van SQL syntax voor verschillende dialecten (SQL:1999, T-SQL, MySql, ...)


Stage – week 4 (18 april – 21 april) Uitdenken van de QueryScript taal AddinTreeView multi-threaded maken Het 'project' formaat vervangen door een robuuster 'solution/project' formaat Gebruikersinterface ontwerpen voor het uitvoeren van database benchmarks Database connecties worden voortaan opgeslaan in het project in plaats van globaal Vergadering met D-N en NSS (2 regionale bedrijven) Stored procedure voor het aanpassen van datums in de AcesHardware database Opendeurdag Stage – week 5 (24 april – 28 april) Tijdelijk de Heimdall eCommerce benchmark hard-coden in Sheridan, voor het testen van het threading framework Query Editor aangepast zodat er gebruik gemaakt wordt van database connecties opgeslaan in het project in plaats van globale connecties Her-ontwerpen van 'new item' en 'new project' dialoog vensters zodat deze logischer in elkaar steken Ontwerpen van ‘Balvenie’, een server side monitor geschreven in C++ Basis implementatie voor windows en linux Makefiles Jobhappening Stage – week 6 (2 mei – 5 mei) Bedenken van het QueryScript concept Syntax uitwerken op papier Lexer en Parser schrijven met behulp van Antlr Herschrijven van de Connection Manager zodat er gebruik gemaakt wordt van de uitbreidbare AddinTreeView Recent Solution functionaliteit verplaatsen naar een eigen RecentSolutionService Balvenie Systeeminformatie ophalen onder Linux en Windows Opzoekwerk naar Solaris


Uitdenken van mogelijke oplossing van de problemen die zich voordoen bij OLTP benchmarks Stage – week 7 (8 mei – 12 mei) Herwerken van de QueryScript syntax zodat deze eenvoudiger te gebruiken en verwerkbaar is Deze veranderingen ook toepassen op de lexer en parser Gebruikersinterface die het toelaat om QueryScript functies en structuren in te geven Stage – week 8 (15 mei – 19 mei) Balvenie SIMC protocol implementeren (XML writer) ClientHandler die socket commands kan verwerken Verbeteringen aan de QueryScript taal ObjectModel maken voor QueryScript StoredConnection klasse als wrapper rond database connecties Stage – week 9 (22 mei – 26 mei) Rename en dubbelklik functionaliteit toevoegen aan de AddinTreeView Algemene Code Editor control Services krijgen de mogelijkheid om dependencies op te geven Aanmaken van QueryScript compiler project Beginselen van een ObjectModel visitor Beginselen van ObjectModel -> AssemblyGenerator converter Stage – week 10 (29 mei – 2 juni) Veranderingen aan de ConnectionProvider / ProviderFactory Ondersteuning voor Sql dialect en parser QueryScript compiler Verder werken aan de visitor en converter Uitdenken van ‘Parameter Origin’ systeem dat toelaat parameters in sql statements te randomizen CompileView dat de compileer status van een QueryScript structure weergeeft Statement Preview Dialog


Grafische manier om de QueryScript structuur aan te passen FunctionView Grafische manier om de verschillende dialecten op te vullen voor elke QueryScript functie Stage – week 11 (5 juni – 9 juni) Afwerken van de QueryScript compiler Implementatie van een ObjectPool die toelaat om objecten van insert/update/delete statements te hergebruiken (oplossing OLTP probleem) Grafische manier om de oorsprong van een parameter te bepalen Onderzoek naar het automatisch positioneren van ER diagrammen Asbtracte basis voor Sql Parser met overrides voor elk dialect DynamicBenchmark klasse die dient als basis voor elke Throughput benchmark Implementatie voor de GetConstraints methode in de MySql provider Bugfixes Stage – week 12 (12 juni – 16 juni) Balvenie Linux socket implementatie Ondersteuning voor cpu belasting voor linux Client monitoring Resultaten koppelen aan benchmark Formulier om server informatie weer te geven AppDomain assembly resolve Bugfixes


Verslagen Brecht Kets

Weekverslag: Week - 4 (6 - 10 februari) Aangezien onze projectweken een voorbereiding op de stage waren begin ik bij week -4. Opzetten build environment Onderzoek naar Build System Nant, MakeFiles en msBuild. Onze keuze is gevallen op msBuild wegens de integratie met visual studio. Onderzoek naar Unit tests Nunit, aut, zanebug Onze keuze is gevallen op Nunit wegens de onstabiele aard van de andere. Onderzoek naar Version Control Systems CVS, SVN Onze keuze is gevallen op SVN omdat dit recenter is dan CVS, we gebruiken TortoiseSVN. Opzetten Logging framework LogForNet Komt voor uit de Apache Logging Service. Cross Language. Onderzoek naar opvragen van metadata van verschillende databases. Dit heeft als doel een enterprise manager te maken die alle databases aankan.

Weekverslag: Week - 3 (13 - 17 februari) Implementatie van DatabaseLibrary Wrapper voor verschillende databaseconnecties, zoals MsSqlServer, Sybase, Mysql,Oracle,DB2 en PostgreSql Mogelijkheid om metadata van de databases op te vragen Zo mudulair en aanpasbaar mogelijk: gebaseerd op plugins Databases Installatie MySql op verschillende servers Aanpassen van dbBench 2004 en 2005 om te werken met mysql5 Fout in het shared memory van MySql 5.016: upgraden naar 5.018 MySql 5.0 werkt niet met oude clients: overwegen om zelf een nieuwe interim client te schrijven Onderzoek naar optimalisatie van MySql Installatie van PostgreSql


Aanpassen van dbBench 2004 zodat hij kan werken met PostgreSql

Weekverslag: Week - 2 (20 - 24 februari) Beslissing om zelf een interim benchmark te schrijven: Heimdall Mythische betekenis: The watcher, he never sleeps and can see in the dark vanaf scratch benchmark vlug geschreven MySql Fout in dbBench 2004 met mysql is een fout in de manier waarop de mysqldriver met WinSock omgaat: deze fout hebben we niet onder mono-linux Heimdall werkt alle versies van MySql Werkt ook voor MsSql queries zijn database afhankelijk (eigen dialect) Installatie van Sybase Installatie van Sybase op Linux en Solaris. Sql parser Na een vergadering met B-N besloten dat we een SqlParser nodig hebben Sql 99 parser Om logfiles in de lezen Voor het randomizen van parameters We gebruiker Antlr Samenwerking met Ben Motmans

Weekverslag: Week - 1 (6 - 10 maart) Updaten Heimdall update Sybase update MySql ODBC update db2 update PostgreSQL Installatie Sybase Installatie Error handling Optimalisatie


Installatie DB2 Installatie Error handling Optimalisatie Sheridan ConnectionManager schrijven voor metadatalibraries Control die de parser demonstreert (ben motmans)

Weekverslag: Week 1 (13 - 17 maart) DB2 Onderzoek naar optimalisatie van db2 Onderzoek naar fouten van db2 op solaris Convertie van de bench database naar db2 Sybase Onderzoek naar optimalisatie van Sybase Convertie van onze bench database naar sybase Threading Onderzoek naar Threading in .net en de .net threadpool Algemeen Vergadering omtrent de huidige status en de vorderingen die nodig zijn tegen de alpha release van Sheridan Vastleggen van de datum van de alpha release van Sheridan Ondersteunen van het Research Team Het research team ondersteunen met vragen omtrent Heimdall of andere software.

Weekverslag: Week 2 (20 - 24 maart) Sybase Convertie van SQL server naar solaris Sybase Schrijven van een custom convertion tool in c# DB2 Error oplossen die db2 geeft na optimalisatie (waarvoor herinstallatie nodig is.


Onderzoek naar optimalisatie van db2 Floating Points opvragen tijdens Bert zijn bench Onderzoek naar AMD CodeAnalist Onderzoek naar VTune Uitvoeren van de test via PFP (een programma geschreven door een medewerker van sun (programma blijkt buggy te zijn, test 1 maal correct uitgevoerd en 2de test gaf onmogelijke resultaten (300% floating point operaties)) Benchmarks Verdergaan met benchen op de Sun T2000 Verdergaan met benchen op de Dual Dual Opteron Threading Nadenken over en beginnen uitwerken van Threading Mechanisme Mogelijkheden van het Threading mechanisme Uitvoeren van workitems Workitems cancellen Workitems geven resultaat terug Mogelijkheid tot doorgeven van een Thread zijn context Mogelijkheid om te wachten tot een workitem klaar is Mogelijkheid om te wachten tot ALLE workitems klaar zijn Pool een vast aantal threads laten gebruiken Workitems hebben een prioriteit Rubuust error handling

Weekverslag: Week 3 (27 - 30 maart) Sybase Aanpassen van de custom convertion tool Manuele afwerking Terugplaatsen van indices Dump nemen Programmatie Vergadering met het software-team omtrent de verdere gang van zaken


Verderwerken aan de threading code DB2 Verder onderzoek naar optimalisaties Fatal error (zie vorige posts) proberen op te lossen MySQL Voorbereiden van vragen en problemen voor onze afspraak met Peter Zaitzev in de USA Heimdall Afwerken Heimdall Technische documentatie: http://users.pandora.be/innodesign/stage/heimdall/index.html | http://users.pandora.be/innodesign/stage/heimdall/Heimdall.chm White Paper: http://users.pandora.be/innodesign/stage/heimdall/Heimdall.chm Benchmarks Verdergaan met benchen op de Sun T2000 Verdergaan met benchen op de Dual Dual Opteron

Weekverslag: Week 4 (18 - 21 april) MySQL MySQL Document: http://users.pandora.be/innodesign/stage/MySQLOLD.pdf Verdere optimalisaties aan de hand van Peter Zaitzev zijn bemerkingen Verder benchen Vergadering D&N Verslag: zie verslag D&N Vergadering NSS Vergadering met het bedrijf Network and storage solutions. Benchmarks Verdergaan met benchen op de Sun T2000 Verdergaan met benchen op de Dual Dual Opteron Beginnen met benchen op de HP Proliant DL385


Weekverslag: Week 5 (24 - 28 april) MySQL Verder Tunen Resultaten analyseren Onderzoek naar de schaling problemen onder Linux Schalingproblemen zijn niet aanwezig op Solaris, die weliswaar wel slechter presteert C# Maken van een welcomepage voor Sheridan met onlangs geopende projecten Afwerken Threading code Technische documentatie Threading code: http://users.pandora.be/innodesign/stage/Sheridan/Threading/index.html | http://users.pandora.be/innodesign/stage/Sheridan/Threading/Sheridan.Threadi ng.chm C++ Onderzoek naar C++ Nodig voor Balvenie, onze server side monitoring tool Ook nodig voor Intel workshop over multithreading en game development in Londen Benchmarks Verdergaan met benchen op de Sun T2000 Verdergaan met benchen op de Dual Dual Opteron Verdergaan met benchen op de HP Proliant DL385 Beginnen met benchen op de MSI Serverworks 1U Rackmount Server K2102A2M

Weekverslag: Week 6 (2 - 5 mei) MySQL Analyse resultaten Onderzoek verschillen => NUMA - SMP => linux kernel aanpassen Installatie van MySQL op HP DL 585


C++ Verdere studie van C++ Benchmarks Verdergaan met benchen op de Sun T2000 Verdergaan met benchen op de Dual Dual Opteron Verdergaan met benchen op de HP Proliant DL385 Verdergaan met benchen op de MSI Serverworks 1U Rackmount Server K2102A2M Beginnen met benchen op de HP Proliant DL585 DB2 Tijl en ik namen het onderzoek van DB2 over Installatie Optimalisatie PostgreSql Updaten Heimdall met nieuwe driver Onderzoek naar optimalisaties

Weekverslag: Week 7 (8 - 12 mei) PostgreSQL Onderzoek naar optimalisatie DB2 Onderzoek naar optimalisatie Onderzoek naar fouten op 64 bit-systemen Suse Alle tests herhalen op Suse Heimdall Heimdall verder optimaliseren en uitbouwen

Weekverslag: Week 8 (15 - 19 mei) Intel


Voorbereiden voor de Intel workshop te londen Intel workshop te londen Samenvatting: http://users.pandora.be/innodesign/stage/MigratingToMulticore.pdf Programmeren Onderzoek naar C++ programmeren Onderzoek naar OpenMP Onderzoek naar MPI Software Onderzoek naar VTune Dolmen Meeting met Dolmen omtrent aanwezigheid op de ontbijtmeeting

Weekverslag: Week 9 (22 - 26 mei) Sheridan Implementatie van de welcompage via RecentSolutionService Ini-file parser Begin van de implementatie van het randomizing-mechanisme Algemeen Ondersteuning van het hardware-team

Weekverslag: Week 10 (29 mei – 2 juni) Sheridan Afwerken van de implementatie van het randomizing-mechanisme Implementatie van de Balanced Concurrency Benchmark SqlImportDialog => custom c# via assemblygenerator laten werkens Txt – xls import Bugfixes + todo’s

Weekverslag: Week 11 (5 – 9 juni)


Sheridan Bugfixes aan de implementatie van het randomizing-mechanisme Afwerken van de implementatie van de Balanced Concurrency Benchmark Bugfixes + todo’s Algemeen Voorstelling voor D&N Voorstelling voor Intel Nederland Balvenie Implementatie van een Linux socket

Weekverslag: Week 12 (12 – 16 juni) Sheridan Afwerking + bugfixes Algemeen Presentatie voor het innovatiecentrum West-Vlaanderen


Stageverslagen Sam Van Broeck

Weekverslag : Week 1 DB2 Onderzoek naar optimalisatie van db2 Onderzoek naar fouten van db2 op solaris Onderzoek naar driver include voor heimdall Multi-Threading Onderzoek naar Multi-Threading in .Net Heimdall :: drivers onderzoek naar 64-bit modus Algemeen Vergadering omtrent de huidige status en de vorderingen die nodig zijn tegen de alpha release van Sheridan Vastleggen van de datum van de alpha release van Sheridan Java script forum met Bert Devriese Ondersteunen van het Research Team ivm DB2

Weekverslag : Week 2 DB 2 Onderzoek optimalisaties Waarom crasht DB2 na uitvoeren standaard ingebouwde optimalisaties Registratie eindwerken Opstellen van teksten bruikbaar bij eindwerk dotatie Registratie voor Software Team bij Leiedal Registratie voor Software Team bij Kennisvaloratie Heimdall Nieuwe approach voor includen drivers :: msm packages Algemeen


Ondersteuning Hardware Team Floating Point controle met VTune Floating Point controle met AMD Code Analyst Floating Point controle met GDB (Gnu DeBug) Grafisch werk Maken van 2 affiches voor voorstelling PWO Project Before After schema

Weekverslag : week 3 DB 2 Verder onderzoek naar optimalisaties Update van drivers Grafisch werk Maken van 2 affiches voor voorstelling PWO Project Algemene voorstelling Presentatie voorbereiden en maken Algemeen Uitleg over parser Overlook Sheridan met current veranderingen Gui debugging General debugging

Weekverslag : week 4 DB 2 Algemene ondersteuning Monitoring Onderzoek beste manier voor zowel client als server Server side zal gebeuren in C++ => Brecht en Ben (Balvenie) Vergaderingen


Statusvergadering met team Update vergadering met Johan D&N :: zie verslag D&N Grafisch werk Maken van voorstellingsaffiche voor opendeurdag

Weekverslag : week 5 Monitoring Realtime grafieken Kort gezocht op implementatie met WPF, maar achterwege gelaten, is nog in een tevroeg stadium

Weekverslag : week 6 Monitoring Uitdenken protocol voor communicatie tussen server client SIMC protocol :: zie Sheridan.Monitoring XML structuur Algemeen Ben en Brecht ambeteren met lastige vragen Bug Installatie van Bugzilla Configuratie Bugzilla

Weekverslag : week 7 Bug Implementeren in Sheridan Raportering en opvolging Upgrade van db (MySql 5.0) na een downgrade van Tijl Monitoring Implementatie in Sheridan


Client socket (C#.Net)

Verdere weekverslagen Updaten van de weekverslagen Uitschrijven projectdossier Maken van brochures voor Fientje Moermans Maken A0 promotie affiche Opvolgen Kennisvaloratie en Leiedal Verzorgen PR ontbijtmeeting met Innovatiecentrum West-Vlaanderen Ontwikkeling van Import van logfiles Bugfixing


Verslag D&N Athena framework (UTF8) :: Wim Debreuck (korte punten samenvatting)

Werkbenodigdheden :: Server = Dual Dual Opteron met Windows 2003 32 bit versie Client = Dual Opteron met Windows Xp 32 bit versie De Athena software wordt geplaatst op onze server. Vereisten om deze werkende te krijgen zijn op de server : java 1.5 jre (en voor de gemakkelijkheid toevoegen aan bin path) MySql (laatste stable versie) Client : J#.Net .Net Framework 1.1. Bij de installatie van MySql onthouden we dat als je via de grafische interface in Windows installeert dat je geen beveiligings instelling toepast. Dit doe je best nadien. Reden : na installatie kan het zijn dat je paswoord gereset wordt naar een onbekend paswoord. Dit heeft volgens ons te maken met een bug in het huidige installer programma.

Korte toelichting van het programma GIS VMI Stock simulator: De bedoeling is om toekomst gericht, over een x aantal maanden, het stockverloop te voorspellen aan de hand van opgegeven stockparameters. De bedoeling van het geheel is dat je een overzicht krijgt van de stock zodat er met een zo laag mogelijke stock en stockbreak (stuks dat je niet kan leveren) en zo groot mogelijke continuïteit te garanderen (deze ligt gewoonlijk rond de 98%). Dit is zeer SELECT intensief. De server kan je starten via het batch bestand startserver. Deze draait dan als een standalone versie. Je kan hem ook als service draaien. Als logging framework wordt Log4J gebruikt, een loggingservice van het Apache project : http://logging.apache.org/log4j/docs/ server.properties is de file waar je aanpassingen moet maken als je je db ergens anders plaatst. Hierin worden onder andere de login en pwd bijgehouden. Als je optimalisatie parameters wilt gebruiken om Java Virtual Machine te tunen moet je zijn in dostart.bat. De parameter dat wij er bij hebben gevoegd is -


Xmx=1024m (hoofdlettergevoelig). Deze zorgt ervoor het maximaal aanspreekbare geheugen. (bij een voorspelling van 40 jaar crasht de Virtual Machine op onze server, alhoewel deze 4 gig ter beschikking heeft). Momenteel is de maximale voorspelling gezet op 36 jaar. Eerst werd een laptop gebruikt Client, hierbij viel het Wim meteen op dat de flow veel trager was dan in andere omstandigheden. Zijn gok is dat onze server te snel is, waardoor de queue zeer snel vol loopt en de client kan deze niet snel genoeg uitlezen. -> Dit geeft vertekende resultaten als je de verhouding progressbar en grafiek bekijkt.

Hoe een simulatie starten ??? Als datasource kan er gebruik gemaakt worden van een .xls of een ODBC bron. De server leest deze bron eenmalig in en dumpt ze in de MySql db en maakt de data persistent. Dit moet maar éénmalig gebeuren, config file activeren. Dit is een bestand met alle paramaters voor het stockbeheer. Daarna klik je op start. Er gebeurt een snelle syncronisatie en dan begint de simulatie.

Wat is belangrijk voor D&N De responstijd. Hoe lang duurt het voordat 10 clients gedaan hebben met het simulatie. Dit is belangrijker dan de grens van maximum aantal clients te zoeken. Om een test scenario op te zetten voldoet het om een 10 tal clients met een zelfde configuratie te samen doen simuleren.

Project aangeboden door. Ben Motmans, Brecht Kets en Sam Van Broeck

Recommend Documents