Jump to content
Have You Played Atari Today?
2600|5200|7800|Lynx|Jaguar|Forums|Store  

JamesD

Members
 View Profile  See their activity

  • Content Count

    8,999

  • Joined

  • Last visited

  • Days Won

    6

Posts posted by JamesD

  1. Posted · Edited by JamesD

    No sort change, unrolled data statements, names and numbers, 561 names   
    MC-10 New ROM
    Scan data, dimension, load data, sort, check sort, print names 171 seconds

    Scan data, dimension, load data, sort  149 seconds
    Dimension, load data, sort, check sort, print names 159 seconds
    *edit*
    Non-unrolled data statements are a second or so faster

  2. Posted · Edited by JamesD

    2 hours ago, Faicuai said:

    What are your timings for 561 names on Banana-sort? (Screen updates = OFF while sorting)

     

    Together with FastBasic's sort, it is probably the simplest and cleanest to port to ANY Basic version... It is not a speed-queen because it spends 70% of sort time rebuilding run-time status of sort-index, immediately after each iteration.... but that is a 16-bit heavy operation, in essence... you should try it!

    With comb sort as is, 561 names, no numbers... the MC-10 New ROM drops to 167 seconds.
    No point in timing more since that's the fastest of the lot till I look at the "banana sort" or FastBasic's sort.
    FasBasic supports INTs so that may not be feasible. Those would all be single precision on MS BASIC.
    *edit*
    That's dimension, load, sort, print btw.

  3. Posted

    I went to do a new build of the MC-10 ROM with the 16 bit string compare disabled, and found the define to enable it was commented out.
    Using the 16 bit string compare drops the last test I did from 270, to 268, beating the standard MC-10 ROM by a couple more seconds.  Most of the speed improvement probably comes from the last 4 or 5 passes where the data is almost in order, and there are a lot more compares.
    The more strings that are similar, the more of a speed improvement it will offer, especially with large data sets.
    I'm guessing the numbers will converge if the amount of data is reduced, and the similarity is also reduced.
    While it is faster here, it's not by much.  A faster sort should have fewer compares, so the speed improvement will probably be even less.
    Dropping the test to see if the data is in order will also reduce the speedup.
    The only reason for that in the first place is to see if the sort is working, and that has been fixed.
    Verdict... meh.

    Okay, so we have a lot of numbers, and several approaches to solving this sort of task.
    But where does that leave a common benchmark?
    How many names do we need to limit it to so we can time using the same data on every version?
    What happens if we sort on every data field in the original data once, what would the impact be?
    That shouldn't be difficult in any version, but will sorting based on the numeric fields in the data have a significant impact on the Atari code using a line for each item?  Memory will be the biggest impact in MS BASIC.
     

  4. Posted

    49 minutes ago, drpeter said:

    Suggestion: Line 3: since F is a constant (0.21) and G-G*F simplifies to G*(1-F) =G*(1-0.21)=G*0.79, you could just write this a simply G=INT(G*0.79) and do away with the variable F altogether.  Or, if you want to keep it, make F=0.79 and this term G=INT(G*F).

    Microsoft BASIC doesn't tokenize constants, so it's best left that way for MS BASIC. 
    Your last suggestion should be faster, but given the number of times it's executed, I won't be able to tell the difference.
     

  5. Posted

    4 hours ago, drpeter said:

    ...

    Wrt the gap, my understanding is that larger gaps sometimes can finish quicker but in other datasets end up stuck on multiple passes with a gap of 1 from having come down too quickly. I'm assuming therefore that for the 561 name data we should try reducing the gap...

     

    However, for the 561 dataset F=1.4008 seems about optimal, reducing the number of passes from 28 to 19 and the time for the sort itself by 28%. Exactly 1.3 just seems like a randomly bad figure for this dataset.

     

    I think it's a recognised drawback that the optimal F value for a comb sort is not easily knowable, but averages to about 1.3 across datasets, but sometimes, as in this case, 1.3 will be an unlucky choice.

    I start with the same gap, but calculate it differently in the loop.
     

    Spoiler

    0 I=0:G=I:N=I:C=I:D=I:E=I:NW=I:H=I:T=I:O=1:Z=0:GOTO20
     

    'comb sort.  
    'p = what we divide the array size by to get the gap
    'G = the gap
    'using nested for loops avoids having to perform a line search that would
    'happen using GOTO. The address is simply pulled off of the stack.
    'using STEP 0 keeps FOR NEXT from changing the variable and the endless loop
    'exits once the exit condition is achieved
    'This revision prevents the 0 gap pass, and duplicate gaps if no swap took place the first time
    'It checks the T temp variable used to swap indexes to see if a swap took place
    'We start the array index at 1, so T should never = 0 if a swap takes place.
    'Starting the array at 0 could break this code 
     

    1 Q=O:F=.21:G=INT(N/1.3):FORT=OTOZSTEPZ:T=0:PRINT"PASS =";Q;"GAP =";G
    2 FORI=OTON-G:IFA$(B(I))>A$(B(I+G))THENT=B(I):B(I)=B(I+G):B(I+G)=T
    3 NEXT:Q=Q+O:G=INT(G-G*F):IFG<OTHENG=O
    4 IFG>1THENT=1
    5 NEXT:RETURN

    20 ' start of main code

     

  6. Posted

    BASIC XL didn't include a fast math ROM, but if Atari had given a shnizzle, they could have included BASIC XL in the XL series.
    They probably could have included a fast math ROM as well, that's the main difference between XL and XE versions.
    Then they could have offered upgrades for the 400/800.

    Sucks that they didn't.  One of the biggest talking points against the Atari could have been turned into one of it's strengths.

    The quirk with Comb sort is probably the calculation of the gap. 
    Try my modification for calculating the gap.  It stays with larger gaps longer.  It takes more passes with 891, but the time was less.
     

  7. Posted

    4 minutes ago, drpeter said:

    OK, here are some timings for BASIC XL 1.03 (1983) & BASIC XE 4.1 (1985), using their native string arrays to do the sort.

    All: Altirra 3.20, XE, stock XL/XE/XEGS ROM Rev 04, no patches, 128K, PAL, ANTIC DMA off, OSS BASIC FAST function enabled (pre-compiles table of memory addresses of line numbers at start of run-time)

     

    BASIC XL, Names 561: Check data dimensions, load & sort:  157.7 secs       Dimension, load, sort, check & print:  169.7 secs

    BASIC XE, Names 561: Check data dimensions, load & sort:  135.9 secs       Dimension, load, sort, check & print:  147.1 secs

    BASIC XE, Names 891: Check data dimensions, load & sort:  216.4 secs       Dimension, load, sort, check & print:  234.5 secs  (program loaded into extended memory with EXTEND function)

    SORTV1.TXT 33.1 kB · 1 download SORTV1.BAS 27.37 kB · 1 download SORTV15.BAS 18.33 kB · 1 download

    Reminder, they support DEEK, and DOKE, so it looks like the code could be faster.

  8. Posted

    The real advantage to Turbo Basic is definitely going to be the compiler, but you are basically in a compiler/accelerator arms race at that point.
    The Turbo BASIC version also allows the Atari to skip the data reading loop entirely, which might be considered cheating on the benchmark.
    My question here is, but what if the data is in a file?  Does that specific optimization go out the window?
    You can always switch the data read loop to a file read, but this?  
    It works well for constant data that can fit in DATA statements, but not as well for data like a regularly updated contact list.
    I only used data statements because the MC-10 only supports tape out of the box, and benchmarking tape/drives doesn't make much sense.

    If you use a different sort, every version would be faster by doing the same, and all my timings were the larger list of names.  If using a smaller list is required, I'm okay with that, and I'm okay with a different sort as long as every machine has the same.
    If you benchmark an Apple II with one sort, and again with another sort, the results are going to be different, so it's not going to make for a meaningful comparison machine vs machine either.
     

  10. Posted · Edited by JamesD

    22 minutes ago, drpeter said:

     I wondered that, and put them back in. Didn't really make much difference.  But as noted above, 90%+ of the time elapsed is on the sort routine with this benchmark.

    Converting from ASCII to BCD might be faster than ASCII to single precision floating point.
    It makes around 20 seconds difference give or take a little by machine on MS BASIC.

    Clearly, the array indexing is a bit of a roadblock for Atari BASIC.
    I wonder about the OSS BASIC XL, and OSS BASIC XE carts. 
    The XL manual is copyright 1983, so that also pushes up when a fast version might be possible, and the XL manual mentions string arrays.
    BASIC XE has SORTDOWN, and SORTUP commands btw, but that's a bit of a cheat here. 
    *edit*
    DEEK, and DOKE are also mentioned in the XL manual.

  11. Posted · Edited by JamesD

    6 hours ago, drpeter said:

    OK, so here's an interesting pomegranate.

     

    I tried Bill Wilkinson's interesting suggestion from COMPUTE! magazine for implementing string arrays simply by holding the data in DATA statements and accessing them using RESTORE A+index: READ X$. https://archive.org/details/BillWilkinsonArticles

     

    This, similar to the Fast Basic approach, avoids any need to load the name data into a separate data structure and allows a 48/64K Atari to implement the benchmark for 891 names with bucketloads (nearly 20K) of memory to spare, suggesting that a sort of getting on for 2000 names could be fitted in memory.

     

    It appears marginally slower, however, for this number of names at least, than using numeric array pointers into a long string:

     

    for 561 name sort: for initialising (including counting the data items, dimensioning and initialising the sort index) + sort, other parameters all as previous post

     

    Altirra BASIC 1.56  353 seconds  (DATA statements) vs 320 seconds (numeric pointer array to string)

    Atari BASIC Rev.C   689 seconds  (DATA statements) vs 555 seconds (numeric pointer array to string)

    Turbo Basic 1.5      200 seconds  (DATA statements) (interpreted, not compiled)

     

    For full 891 name sort, parameters as above:

     

    Altirra BASIC 1.56  645 seconds  (DATA statements)

    Atari BASIC Rev.C   1288 seconds  (DATA statements)

    Turbo Basic 1.5      300 seconds  (DATA statements) (interpreted, not compiled)

     

      Reveal hidden contents

    0 POKE 559,0:POKE 20,0:POKE 19,0:POKE 18,0:DIM K$(30),O$(30),CL$(1):GOTO 45
    6 RETURN 
    10 P=1:F=1.3:G=1:L=0:REM SORT SUBROUTINE
    13 L=L+1:P=P*F:G=INT(N/P):IF G<1 THEN G=1
    14 NW=N-G:? "PASS ";L;" GAP ";G;"  ";:IF G=1 THEN S=1
    15 FOR I=0 TO NW-1:RESTORE 31001+B(I):READ K$:RESTORE 31001+B(I+G):READ O$
    16 IF K$>O$ THEN T=B(I):B(I)=B(I+G):B(I+G)=T:S=0
    21 NEXT I:IF S=1 THEN RETURN 
    22 GOTO 13
    25 ? : ? "CHECKING SORT...  ";:R=0:FOR I=0 TO N-2:REM CHECK SORT ORDER ROUTINE
    26 RESTORE 31001+B(I):READ K$:RESTORE 31001+B(I+1):READ O$
    27 IF K$>O$ THEN ? "OUT OF ORDER ";K$:R=1
    30 NEXT I:? :RETURN 
    40 FOR I=0 TO N-1:RESTORE 31001+B(I):READ K$:? K$;" ";:NEXT I:RETURN 
    44 REM MAIN
    45 N=0:CL$=CHR$(125)
    51 REM K$=TEMP,N$=NAME ARRAY,S()=SUBSTRING START PTRS
    53 REM CL$=CLEAR SCREEN, POKE 752,1 =SYSTEM CURSOR OFF
    55 ? CL$:? "COMB SORT MOST POPULAR SURNAMES":? : ? "LOADING DATA...  ";
    56 READ K$:IF K$<>"$" THEN N=N+1:GOTO 56
    57 DIM B(N-1)
    60 FOR I=0 TO N-1:B(I)=I:NEXT I
    70 ? N;" NAMES LOADED":? 
    72 IF PEEK(20)>240 THEN 72
    75 T1=(PEEK(18)*256*256+PEEK(19)*256+PEEK(20))/50
    80 GOSUB 10:REM SORT ROUTINE
    81 IF PEEK(20)>240 THEN 81
    82 T2=(PEEK(18)*256*256+PEEK(19)*256+PEEK(20))/50
    85 GOSUB 25:REM CHECK SORT ORDER
    86 IF PEEK(20)>240 THEN 86
    87 T3=(PEEK(18)*256*256+PEEK(19)*256+PEEK(20))/50
    92 GOSUB 40:REM PRINT SORTED LIST
    93 IF PEEK(20)>240 THEN 93
    94 T4=(PEEK(18)*256*256+PEEK(19)*256+PEEK(20))/50
    96 ? : ? : ? "ELAPSED: ";T1;",";T2;",";T3;",";T4;" SECONDS"
    98 ? : ? : ? "DONE":POKE 752,0:POKE 559,34:END 
    31001 DATA SMITH
    31002 DATA JOHNSON
    31003 DATA WILLIAMS
    31004 DATA JONES
    31005 DATA BROWN
    31006 DATA DAVIS
    31007 DATA MILLER
    31008 DATA WILSON
    31009 DATA MOORE
    31010 DATA TAYLOR
    31011 DATA ANDERSON
    31012 DATA THOMAS
    31013 DATA JACKSON
    31014 DATA WHITE
    31015 DATA HARRIS
    31016 DATA MARTIN
    31017 DATA THOMPSON
    31018 DATA GARCIA
    31019 DATA MARTINEZ
    31020 DATA ROBINSON
    31021 DATA CLARK
    31022 DATA RODRIGUEZ
    31023 DATA LEWIS
    31024 DATA LEE
    31025 DATA WALKER
    31026 DATA HALL
    31027 DATA ALLEN
    31028 DATA YOUNG
    31029 DATA HERNANDEZ
    31030 DATA KING
    31031 DATA WRIGHT
    31032 DATA LOPEZ
    31033 DATA HILL
    31034 DATA SCOTT
    31035 DATA GREEN
    31036 DATA ADAMS
    31037 DATA BAKER
    31038 DATA GONZALEZ
    31039 DATA NELSON
    31040 DATA CARTER
    31041 DATA MITCHELL
    31042 DATA PEREZ
    31043 DATA ROBERTS
    31044 DATA TURNER
    31045 DATA PHILLIPS
    31046 DATA CAMPBELL
    31047 DATA PARKER
    31048 DATA EVANS
    31049 DATA EDWARDS
    31050 DATA COLLINS
    31051 DATA STEWART
    31052 DATA SANCHEZ
    31053 DATA MORRIS
    31054 DATA ROGERS
    31055 DATA REED
    31056 DATA COOK
    31057 DATA MORGAN
    31058 DATA BELL
    31059 DATA MURPHY
    31060 DATA BAILEY
    31061 DATA RIVERA
    31062 DATA COOPER
    31063 DATA RICHARDSON
    31064 DATA COX
    31065 DATA HOWARD
    31066 DATA WARD
    31067 DATA TORRES
    31068 DATA PETERSON
    31069 DATA GRAY
    31070 DATA RAMIREZ
    31071 DATA JAMES
    31072 DATA WATSON
    31073 DATA BROOKS
    31074 DATA KELLY
    31075 DATA SANDERS
    31076 DATA PRICE
    31077 DATA BENNETT
    31078 DATA WOOD
    31079 DATA BARNES
    31080 DATA ROSS
    31081 DATA HENDERSON
    31082 DATA COLEMAN
    31083 DATA JENKINS
    31084 DATA PERRY
    31085 DATA POWELL
    31086 DATA LONG
    31087 DATA PATTERSON
    31088 DATA HUGHES
    31089 DATA FLORES
    31090 DATA WASHINGTON
    31091 DATA BUTLER
    31092 DATA SIMMONS
    31093 DATA FOSTER
    31094 DATA GONZALES
    31095 DATA BRYANT
    31096 DATA ALEXANDER
    31097 DATA RUSSELL
    31098 DATA GRIFFIN
    31099 DATA DIAZ
    31100 DATA HAYES
    31101 DATA MYERS
    31102 DATA FORD
    31103 DATA HAMILTON
    31104 DATA GRAHAM
    31105 DATA SULLIVAN
    31106 DATA WALLACE
    31107 DATA WOODS
    31108 DATA COLE
    31109 DATA WEST
    31110 DATA JORDAN
    31111 DATA OWENS
    31112 DATA REYNOLDS
    31113 DATA FISHER
    31114 DATA ELLIS
    31115 DATA HARRISON
    31116 DATA GIBSON
    31117 DATA MCDONALD
    31118 DATA CRUZ
    31119 DATA MARSHALL
    31120 DATA ORTIZ
    31121 DATA GOMEZ
    31122 DATA MURRAY
    31123 DATA FREEMAN
    31124 DATA WELLS
    31125 DATA WEBB
    31126 DATA SIMPSON
    31127 DATA STEVENS
    31128 DATA TUCKER
    31129 DATA PORTER
    31130 DATA HUNTER
    31131 DATA HICKS
    31132 DATA CRAWFORD
    31133 DATA HENRY
    31134 DATA BOYD
    31135 DATA MASON
    31136 DATA MORALES
    31137 DATA KENNEDY
    31138 DATA WARREN
    31139 DATA DIXON
    31140 DATA RAMOS
    31141 DATA REYES
    31142 DATA BURNS
    31143 DATA GORDON
    31144 DATA SHAW
    31145 DATA HOLMES
    31146 DATA RICE
    31147 DATA ROBERTSON
    31148 DATA HUNT
    31149 DATA BLACK
    31150 DATA DANIELS
    31151 DATA PALMER
    31152 DATA MILLS
    31153 DATA NICHOLS
    31154 DATA GRANT
    31155 DATA KNIGHT
    31156 DATA FERGUSON
    31157 DATA ROSE
    31158 DATA STONE
    31159 DATA HAWKINS
    31160 DATA DUNN
    31161 DATA PERKINS
    31162 DATA HUDSON
    31163 DATA SPENCER
    31164 DATA GARDNER
    31165 DATA STEPHENS
    31166 DATA PAYNE
    31167 DATA PIERCE
    31168 DATA BERRY
    31169 DATA MATTHEWS
    31170 DATA ARNOLD
    31171 DATA WAGNER
    31172 DATA WILLIS
    31173 DATA RAY
    31174 DATA WATKINS
    31175 DATA OLSON
    31176 DATA CARROLL
    31177 DATA DUNCAN
    31178 DATA SNYDER
    31179 DATA HART
    31180 DATA CUNNINGHAM
    31181 DATA BRADLEY
    31182 DATA LANE
    31183 DATA ANDREWS
    31184 DATA RUIZ
    31185 DATA HARPER
    31186 DATA FOX
    31187 DATA RILEY
    31188 DATA ARMSTRONG
    31189 DATA CARPENTER
    31190 DATA WEAVER
    31191 DATA GREENE
    31192 DATA LAWRENCE
    31193 DATA ELLIOTT
    31194 DATA CHAVEZ
    31195 DATA SIMS
    31196 DATA AUSTIN
    31197 DATA PETERS
    31198 DATA KELLEY
    31199 DATA FRANKLIN
    31200 DATA LAWSON
    31201 DATA FIELDS
    31202 DATA GUTIERREZ
    31203 DATA RYAN
    31204 DATA SCHMIDT
    31205 DATA CARR
    31206 DATA VASQUEZ
    31207 DATA CASTILLO
    31208 DATA WHEELER
    31209 DATA CHAPMAN
    31210 DATA OLIVER
    31211 DATA MONTGOMERY
    31212 DATA RICHARDS
    31213 DATA WILLIAMSON
    31214 DATA JOHNSTON
    31215 DATA BANKS
    31216 DATA MEYER
    31217 DATA BISHOP
    31218 DATA MCCOY
    31219 DATA HOWELL
    31220 DATA ALVAREZ
    31221 DATA MORRISON
    31222 DATA HANSEN
    31223 DATA FERNANDEZ
    31224 DATA GARZA
    31225 DATA HARVEY
    31226 DATA LITTLE
    31227 DATA BURTON
    31228 DATA STANLEY
    31229 DATA NGUYEN
    31230 DATA GEORGE
    31231 DATA JACOBS
    31232 DATA REID
    31233 DATA KIM
    31234 DATA FULLER
    31235 DATA LYNCH
    31236 DATA DEAN
    31237 DATA GILBERT
    31238 DATA GARRETT
    31239 DATA ROMERO
    31240 DATA WELCH
    31241 DATA LARSON
    31242 DATA FRAZIER
    31243 DATA BURKE
    31244 DATA HANSON
    31245 DATA DAY
    31246 DATA MENDOZA
    31247 DATA MORENO
    31248 DATA BOWMAN
    31249 DATA MEDINA
    31250 DATA FOWLER
    31251 DATA BREWER
    31252 DATA HOFFMAN
    31253 DATA CARLSON
    31254 DATA SILVA
    31255 DATA PEARSON
    31256 DATA HOLLAND
    31257 DATA DOUGLAS
    31258 DATA FLEMING
    31259 DATA JENSEN
    31260 DATA VARGAS
    31261 DATA BYRD
    31262 DATA DAVIDSON
    31263 DATA HOPKINS
    31264 DATA MAY
    31265 DATA TERRY
    31266 DATA HERRERA
    31267 DATA WADE
    31268 DATA SOTO
    31269 DATA WALTERS
    31270 DATA CURTIS
    31271 DATA NEAL
    31272 DATA CALDWELL
    31273 DATA LOWE
    31274 DATA JENNINGS
    31275 DATA BARNETT
    31276 DATA GRAVES
    31277 DATA JIMENEZ
    31278 DATA HORTON
    31279 DATA SHELTON
    31280 DATA BARRETT
    31281 DATA OBRIEN
    31282 DATA CASTRO
    31283 DATA SUTTON
    31284 DATA GREGORY
    31285 DATA MCKINNEY
    31286 DATA LUCAS
    31287 DATA MILES
    31288 DATA CRAIG
    31289 DATA RODRIQUEZ
    31290 DATA CHAMBERS
    31291 DATA HOLT
    31292 DATA LAMBERT
    31293 DATA FLETCHER
    31294 DATA WATTS
    31295 DATA BATES
    31296 DATA HALE
    31297 DATA RHODES
    31298 DATA PENA
    31299 DATA BECK
    31300 DATA NEWMAN
    31301 DATA HAYNES
    31302 DATA MCDANIEL
    31303 DATA MENDEZ
    31304 DATA BUSH
    31305 DATA VAUGHN
    31306 DATA PARKS
    31307 DATA DAWSON
    31308 DATA SANTIAGO
    31309 DATA NORRIS
    31310 DATA HARDY
    31311 DATA LOVE
    31312 DATA STEELE
    31313 DATA CURRY
    31314 DATA POWERS
    31315 DATA SCHULTZ
    31316 DATA BARKER
    31317 DATA GUZMAN
    31318 DATA PAGE
    31319 DATA MUNOZ
    31320 DATA BALL
    31321 DATA KELLER
    31322 DATA CHANDLER
    31323 DATA WEBER
    31324 DATA LEONARD
    31325 DATA WALSH
    31326 DATA LYONS
    31327 DATA RAMSEY
    31328 DATA WOLFE
    31329 DATA SCHNEIDER
    31330 DATA MULLINS
    31331 DATA BENSON
    31332 DATA SHARP
    31333 DATA BOWEN
    31334 DATA DANIEL
    31335 DATA BARBER
    31336 DATA CUMMINGS
    31337 DATA HINES
    31338 DATA BALDWIN
    31339 DATA GRIFFITH
    31340 DATA VALDEZ
    31341 DATA HUBBARD
    31342 DATA SALAZAR
    31343 DATA REEVES
    31344 DATA WARNER
    31345 DATA STEVENSON
    31346 DATA BURGESS
    31347 DATA SANTOS
    31348 DATA TATE
    31349 DATA CROSS
    31350 DATA GARNER
    31351 DATA MANN
    31352 DATA MACK
    31353 DATA MOSS
    31354 DATA THORNTON
    31355 DATA DENNIS
    31356 DATA MCGEE
    31357 DATA FARMER
    31358 DATA DELGADO
    31359 DATA AGUILAR
    31360 DATA VEGA
    31361 DATA GLOVER
    31362 DATA MANNING
    31363 DATA COHEN
    31364 DATA HARMON
    31365 DATA RODGERS
    31366 DATA ROBBINS
    31367 DATA NEWTON
    31368 DATA TODD
    31369 DATA BLAIR
    31370 DATA HIGGINS
    31371 DATA INGRAM
    31372 DATA REESE
    31373 DATA CANNON
    31374 DATA STRICKLAND
    31375 DATA TOWNSEND
    31376 DATA POTTER
    31377 DATA GOODWIN
    31378 DATA WALTON
    31379 DATA ROWE
    31380 DATA HAMPTON
    31381 DATA ORTEGA
    31382 DATA PATTON
    31383 DATA SWANSON
    31384 DATA JOSEPH
    31385 DATA FRANCIS
    31386 DATA GOODMAN
    31387 DATA MALDONADO
    31388 DATA YATES
    31389 DATA BECKER
    31390 DATA ERICKSON
    31391 DATA HODGES
    31392 DATA RIOS
    31393 DATA CONNER
    31394 DATA ADKINS
    31395 DATA WEBSTER
    31396 DATA NORMAN
    31397 DATA MALONE
    31398 DATA HAMMOND
    31399 DATA FLOWERS
    31400 DATA COBB
    31401 DATA MOODY
    31402 DATA QUINN
    31403 DATA BLAKE
    31404 DATA MAXWELL
    31405 DATA POPE
    31406 DATA FLOYD
    31407 DATA OSBORNE
    31408 DATA PAUL
    31409 DATA MCCARTHY
    31410 DATA GUERRERO
    31411 DATA LINDSEY
    31412 DATA ESTRADA
    31413 DATA SANDOVAL
    31414 DATA GIBBS
    31415 DATA TYLER
    31416 DATA GROSS
    31417 DATA FITZGERALD
    31418 DATA STOKES
    31419 DATA DOYLE
    31420 DATA SHERMAN
    31421 DATA SAUNDERS
    31422 DATA WISE
    31423 DATA COLON
    31424 DATA GILL
    31425 DATA ALVARADO
    31426 DATA GREER
    31427 DATA PADILLA
    31428 DATA SIMON
    31429 DATA WATERS
    31430 DATA NUNEZ
    31431 DATA BALLARD
    31432 DATA SCHWARTZ
    31433 DATA MCBRIDE
    31434 DATA HOUSTON
    31435 DATA CHRISTENSEN
    31436 DATA KLEIN
    31437 DATA PRATT
    31438 DATA BRIGGS
    31439 DATA PARSONS
    31440 DATA MCLAUGHLIN
    31441 DATA ZIMMERMAN
    31442 DATA FRENCH
    31443 DATA BUCHANAN
    31444 DATA MORAN
    31445 DATA COPELAND
    31446 DATA ROY
    31447 DATA PITTMAN
    31448 DATA BRADY
    31449 DATA MCCORMICK
    31450 DATA HOLLOWAY
    31451 DATA BROCK
    31452 DATA POOLE
    31453 DATA FRANK
    31454 DATA LOGAN
    31455 DATA OWEN
    31456 DATA BASS
    31457 DATA MARSH
    31458 DATA DRAKE
    31459 DATA WONG
    31460 DATA JEFFERSON
    31461 DATA PARK
    31462 DATA MORTON
    31463 DATA ABBOTT
    31464 DATA SPARKS
    31465 DATA PATRICK
    31466 DATA NORTON
    31467 DATA HUFF
    31468 DATA CLAYTON
    31469 DATA MASSEY
    31470 DATA LLOYD
    31471 DATA FIGUEROA
    31472 DATA CARSON
    31473 DATA BOWERS
    31474 DATA ROBERSON
    31475 DATA BARTON
    31476 DATA TRAN
    31477 DATA LAMB
    31478 DATA HARRINGTON
    31479 DATA CASEY
    31480 DATA BOONE
    31481 DATA CORTEZ
    31482 DATA CLARKE
    31483 DATA MATHIS
    31484 DATA SINGLETON
    31485 DATA WILKINS
    31486 DATA CAIN
    31487 DATA BRYAN
    31488 DATA UNDERWOOD
    31489 DATA HOGAN
    31490 DATA MCKENZIE
    31491 DATA COLLIER
    31492 DATA LUNA
    31493 DATA PHELPS
    31494 DATA MCGUIRE
    31495 DATA ALLISON
    31496 DATA BRIDGES
    31497 DATA WILKERSON
    31498 DATA NASH
    31499 DATA SUMMERS
    31500 DATA ATKINS
    31501 DATA WILCOX
    31502 DATA PITTS
    31503 DATA CONLEY
    31504 DATA MARQUEZ
    31505 DATA BURNETT
    31506 DATA RICHARD
    31507 DATA COCHRAN
    31508 DATA CHASE
    31509 DATA DAVENPORT
    31510 DATA HOOD
    31511 DATA GATES
    31512 DATA CLAY
    31513 DATA AYALA
    31514 DATA SAWYER
    31515 DATA ROMAN
    31516 DATA VAZQUEZ
    31517 DATA DICKERSON
    31518 DATA HODGE
    31519 DATA ACOSTA
    31520 DATA FLYNN
    31521 DATA ESPINOZA
    31522 DATA NICHOLSON
    31523 DATA MONROE
    31524 DATA WOLF
    31525 DATA MORROW
    31526 DATA KIRK
    31527 DATA RANDALL
    31528 DATA ANTHONY
    31529 DATA WHITAKER
    31530 DATA OCONNOR
    31531 DATA SKINNER
    31532 DATA WARE
    31533 DATA MOLINA
    31534 DATA KIRBY
    31535 DATA HUFFMAN
    31536 DATA BRADFORD
    31537 DATA CHARLES
    31538 DATA GILMORE
    31539 DATA DOMINGUEZ
    31540 DATA ONEAL
    31541 DATA BRUCE
    31542 DATA LANG
    31543 DATA COMBS
    31544 DATA KRAMER
    31545 DATA HEATH
    31546 DATA HANCOCK
    31547 DATA GALLAGHER
    31548 DATA GAINES
    31549 DATA SHAFFER
    31550 DATA SHORT
    31551 DATA WIGGINS
    31552 DATA MATHEWS
    31553 DATA MCCLAIN
    31554 DATA FISCHER
    31555 DATA WALL
    31556 DATA SMALL
    31557 DATA MELTON
    31558 DATA HENSLEY
    31559 DATA BOND
    31560 DATA DYER
    31561 DATA CAMERON
    31562 DATA GRIMES
    31563 DATA CONTRERAS
    31564 DATA CHRISTIAN
    31565 DATA WYATT
    31566 DATA BAXTER
    31567 DATA SNOW
    31568 DATA MOSLEY
    31569 DATA SHEPHERD
    31570 DATA LARSEN
    31571 DATA HOOVER
    31572 DATA BEASLEY
    31573 DATA GLENN
    31574 DATA PETERSEN
    31575 DATA WHITEHEAD
    31576 DATA MEYERS
    31577 DATA KEITH
    31578 DATA GARRISON
    31579 DATA VINCENT
    31580 DATA SHIELDS
    31581 DATA HORN
    31582 DATA SAVAGE
    31583 DATA OLSEN
    31584 DATA SCHROEDER
    31585 DATA HARTMAN
    31586 DATA WOODARD
    31587 DATA MUELLER
    31588 DATA KEMP
    31589 DATA DELEON
    31590 DATA BOOTH
    31591 DATA PATEL
    31592 DATA CALHOUN
    31593 DATA WILEY
    31594 DATA EATON
    31595 DATA CLINE
    31596 DATA NAVARRO
    31597 DATA HARRELL
    31598 DATA LESTER
    31599 DATA HUMPHREY
    31600 DATA PARRISH
    31601 DATA DURAN
    31602 DATA HUTCHINSON
    31603 DATA HESS
    31604 DATA DORSEY
    31605 DATA BULLOCK
    31606 DATA ROBLES
    31607 DATA BEARD
    31608 DATA DALTON
    31609 DATA AVILA
    31610 DATA VANCE
    31611 DATA RICH
    31612 DATA BLACKWELL
    31613 DATA YORK
    31614 DATA JOHNS
    31615 DATA BLANKENSHIP
    31616 DATA TREVINO
    31617 DATA SALINAS
    31618 DATA CAMPOS
    31619 DATA PRUITT
    31620 DATA MOSES
    31621 DATA CALLAHAN
    31622 DATA GOLDEN
    31623 DATA MONTOYA
    31624 DATA HARDIN
    31625 DATA GUERRA
    31626 DATA MCDOWELL
    31627 DATA CAREY
    31628 DATA STAFFORD
    31629 DATA GALLEGOS
    31630 DATA HENSON
    31631 DATA WILKINSON
    31632 DATA BOOKER
    31633 DATA MERRITT
    31634 DATA MIRANDA
    31635 DATA ATKINSON
    31636 DATA ORR
    31637 DATA DECKER
    31638 DATA HOBBS
    31639 DATA PRESTON
    31640 DATA TANNER
    31641 DATA KNOX
    31642 DATA PACHECO
    31643 DATA STEPHENSON
    31644 DATA GLASS
    31645 DATA ROJAS
    31646 DATA SERRANO
    31647 DATA MARKS
    31648 DATA HICKMAN
    31649 DATA ENGLISH
    31650 DATA SWEENEY
    31651 DATA STRONG
    31652 DATA PRINCE
    31653 DATA MCCLURE
    31654 DATA CONWAY
    31655 DATA WALTER
    31656 DATA ROTH
    31657 DATA MAYNARD
    31658 DATA FARRELL
    31659 DATA LOWERY
    31660 DATA HURST
    31661 DATA NIXON
    31662 DATA WEISS
    31663 DATA TRUJILLO
    31664 DATA ELLISON
    31665 DATA SLOAN
    31666 DATA JUAREZ
    31667 DATA WINTERS
    31668 DATA MCLEAN
    31669 DATA RANDOLPH
    31670 DATA LEON
    31671 DATA BOYER
    31672 DATA VILLARREAL
    31673 DATA MCCALL
    31674 DATA GENTRY
    31675 DATA CARRILLO
    31676 DATA KENT
    31677 DATA AYERS
    31678 DATA LARA
    31679 DATA SHANNON
    31680 DATA SEXTON
    31681 DATA PACE
    31682 DATA HULL
    31683 DATA LEBLANC
    31684 DATA BROWNING
    31685 DATA VELASQUEZ
    31686 DATA LEACH
    31687 DATA CHANG
    31688 DATA HOUSE
    31689 DATA SELLERS
    31690 DATA HERRING
    31691 DATA NOBLE
    31692 DATA FOLEY
    31693 DATA BARTLETT
    31694 DATA MERCADO
    31695 DATA LANDRY
    31696 DATA DURHAM
    31697 DATA WALLS
    31698 DATA BARR
    31699 DATA MCKEE
    31700 DATA BAUER
    31701 DATA RIVERS
    31702 DATA EVERETT
    31703 DATA BRADSHAW
    31704 DATA PUGH
    31705 DATA VELEZ
    31706 DATA RUSH
    31707 DATA ESTES
    31708 DATA DODSON
    31709 DATA MORSE
    31710 DATA SHEPPARD
    31711 DATA WEEKS
    31712 DATA CAMACHO
    31713 DATA BEAN
    31714 DATA BARRON
    31715 DATA LIVINGSTON
    31716 DATA MIDDLETON
    31717 DATA SPEARS
    31718 DATA BRANCH
    31719 DATA BLEVINS
    31720 DATA CHEN
    31721 DATA KERR
    31722 DATA MCCONNELL
    31723 DATA HATFIELD
    31724 DATA HARDING
    31725 DATA ASHLEY
    31726 DATA SOLIS
    31727 DATA HERMAN
    31728 DATA FROST
    31729 DATA GILES
    31730 DATA BLACKBURN
    31731 DATA WILLIAM
    31732 DATA PENNINGTON
    31733 DATA WOODWARD
    31734 DATA FINLEY
    31735 DATA MCINTOSH
    31736 DATA KOCH
    31737 DATA BEST
    31738 DATA SOLOMON
    31739 DATA MCCULLOUGH
    31740 DATA DUDLEY
    31741 DATA NOLAN
    31742 DATA BLANCHARD
    31743 DATA RIVAS
    31744 DATA BRENNAN
    31745 DATA MEJIA
    31746 DATA KANE
    31747 DATA BENTON
    31748 DATA JOYCE
    31749 DATA BUCKLEY
    31750 DATA HALEY
    31751 DATA VALENTINE
    31752 DATA MADDOX
    31753 DATA RUSSO
    31754 DATA MCKNIGHT
    31755 DATA BUCK
    31756 DATA MOON
    31757 DATA MCMILLAN
    31758 DATA CROSBY
    31759 DATA BERG
    31760 DATA DOTSON
    31761 DATA MAYS
    31762 DATA ROACH
    31763 DATA CHURCH
    31764 DATA CHAN
    31765 DATA RICHMOND
    31766 DATA MEADOWS
    31767 DATA FAULKNER
    31768 DATA ONEILL
    31769 DATA KNAPP
    31770 DATA KLINE
    31771 DATA BARRY
    31772 DATA OCHOA
    31773 DATA JACOBSON
    31774 DATA GAY
    31775 DATA AVERY
    31776 DATA HENDRICKS
    31777 DATA HORNE
    31778 DATA SHEPARD
    31779 DATA HEBERT
    31780 DATA CHERRY
    31781 DATA CARDENAS
    31782 DATA MCINTYRE
    31783 DATA WHITNEY
    31784 DATA WALLER
    31785 DATA HOLMAN
    31786 DATA DONALDSON
    31787 DATA CANTU
    31788 DATA TERRELL
    31789 DATA MORIN
    31790 DATA GILLESPIE
    31791 DATA FUENTES
    31792 DATA TILLMAN
    31793 DATA SANFORD
    31794 DATA BENTLEY
    31795 DATA PECK
    31796 DATA KEY
    31797 DATA SALAS
    31798 DATA ROLLINS
    31799 DATA GAMBLE
    31800 DATA DICKSON
    31801 DATA BATTLE
    31802 DATA SANTANA
    31803 DATA CABRERA
    31804 DATA CERVANTES
    31805 DATA HOWE
    31806 DATA HINTON
    31807 DATA HURLEY
    31808 DATA SPENCE
    31809 DATA ZAMORA
    31810 DATA YANG
    31811 DATA MCNEIL
    31812 DATA SUAREZ
    31813 DATA CASE
    31814 DATA PETTY
    31815 DATA GOULD
    31816 DATA MCFARLAND
    31817 DATA SAMPSON
    31818 DATA CARVER
    31819 DATA BRAY
    31820 DATA ROSARIO
    31821 DATA MACDONALD
    31822 DATA STOUT
    31823 DATA HESTER
    31824 DATA MELENDEZ
    31825 DATA DILLON
    31826 DATA FARLEY
    31827 DATA HOPPER
    31828 DATA GALLOWAY
    31829 DATA POTTS
    31830 DATA BERNARD
    31831 DATA JOYNER
    31832 DATA STEIN
    31833 DATA AGUIRRE
    31834 DATA OSBORN
    31835 DATA MERCER
    31836 DATA BENDER
    31837 DATA FRANCO
    31838 DATA ROWLAND
    31839 DATA SYKES
    31840 DATA BENJAMIN
    31841 DATA TRAVIS
    31842 DATA PICKETT
    31843 DATA CRANE
    31844 DATA SEARS
    31845 DATA MAYO
    31846 DATA DUNLAP
    31847 DATA HAYDEN
    31848 DATA WILDER
    31849 DATA MCKAY
    31850 DATA COFFEY
    31851 DATA MCCARTY
    31852 DATA EWING
    31853 DATA COOLEY
    31854 DATA VAUGHAN
    31855 DATA BONNER
    31856 DATA COTTON
    31857 DATA HOLDER
    31858 DATA STARK
    31859 DATA FERRELL
    31860 DATA CANTRELL
    31861 DATA FULTON
    31862 DATA LYNN
    31863 DATA LOTT
    31864 DATA CALDERON
    31865 DATA ROSA
    31866 DATA POLLARD
    31867 DATA HOOPER
    31868 DATA BURCH
    31869 DATA MULLEN
    31870 DATA FRY
    31871 DATA RIDDLE
    31872 DATA LEVY
    31873 DATA DAVID
    31874 DATA DUKE
    31875 DATA ODONNELL
    31876 DATA GUY
    31877 DATA MICHAEL
    31878 DATA BRITT
    31879 DATA FREDERICK
    31880 DATA DAUGHERTY
    31881 DATA BERGER
    31882 DATA DILLARD
    31883 DATA ALSTON
    31884 DATA JARVIS
    31885 DATA FRYE
    31886 DATA RIGGS
    31887 DATA CHANEY
    31888 DATA ODOM
    31889 DATA DUFFY
    31890 DATA FITZPATRICK
    31891 DATA VALENZUELA
    32000 DATA $
     

     

    A funny thing happens when you drop the numeric data. 
    It means they can be dropped on the other versions, which drops 3564 string reads, and ASCII to float conversions. 
    Is this where your speedup is actually coming from?

    Results with 891 names, no numbers in data

    Plus/4                                          417
    Plus/4 with screen blanked for sort 292
    MC-10 New BASIC    270 seconds (the 16 bit string compare may be slowing this down)
    MC-10                     286 seconds (this can be sped up just under 3% with a software patch that can be installed at runtime, no ROM change)
    Apple II Plus            337 seconds
    Apple II (1982 or later with accelerator) ~120 seconds
    I don't have one of those boards to test with, so I made a conservative division using the MHz listed on the internet.
    Later boards were faster, and a modern 20MHz accelerator will drop that below 20 seconds.
    This is why I suggested trying to stay in the early years, and higher CPU speeds became more common after 1985.
    The Apple Language System would be somewhat the equivalent of Fast BASIC back in the day, but you'd be using PASCAL. 
    It also uses a bytecode interpreter.

  12. Posted

    42 minutes ago, drpeter said:

    So, it compiles from source to an intermediate code, from which as I understand it the original source cannot be readily reconstructed.

    Nothing inherently wrong with that, of course, but not to my mind an interpreted BASIC in the usual sense.

    I guess one could however argue that BASICs like ATARI BASIC that are pre-tokenised are also, while not going so far as Fast Basic in compiling to an intermediate code, also not exactly like BASICs such as Microsoft, which are only parsed and interpreted at all at runtime.

    It is definitely very different than regular BASIC interpreter you are used to.
    Bytecode interpreters work more like an emulator of a virtual CPU, and the compiler generates code for the virtual CPU.
     

  13. Posted · Edited by JamesD

    2 hours ago, _The Doctor__ said:

     

    If I remember the practice... you put the DATA to be parsed first within the beginning lines and make sure to get as much in as possible per line

    you always make sure to sort from right to left in the list, that also applies to sorting from the end of data to the start...

    always pick a mode that gives the cpu the most available cycles for your sort or number crunch. so on and so forth.

    As examples of what to do started to be offered, a food fight ensued afterwards.

     

    If you want to move the DATA in front of the code, and put more on a line, go for it.
    I think the amount of DATA on a line was due to a line length limit, probably on the MC-10.
    The DATA follows the code, because under MS BASIC any code that searches for a line # <= the current line number causes the interpreter to look for it  starting from the first line, but if Atari does it differently, that's not going to change the code that should stay the same so I have no problem with it. 

    If you want to reverse the loops so they go from the bottom up, using the same core algorithm but in reverse, with the same gaps, that means you are doing the same number of compares, the same number of swaps, and the same number of passes, so I see no problem with that.

    I have no problem with changing the graphics mode to make the most cycles available, or even turning off the display.  
    I even tried that on the Plus/4 for the sort, and I think I already said I didn't care about that, if you are running a job for a long time or overnight, you might turn off the monitor anyway.

    What I have repeatedly said I have a problem with, is switching sort algorithms for one machine, not timing the same things (skipping steps), switching to assembly language... stuff that makes it an apples and oranges comparison, rather than an Apples and Atari's comparison. 

    What I did on the last timings, was read the data, sorted the index, checked the results, and printed the results.
    If you want to skip any of that, I'd have to time everything over.
    I also used the gap calculation in the loop that only used a multiply. 
    It makes more passes, but it seemed to be a little faster, and I posted the two versions of the sort, with and without that.


    *edit*  The code might not be doing the same number of swaps, but I think it won't matter much here.

  14. Posted

    19 minutes ago, Faicuai said:

     

    Ok, let me make sure everyone here gets this as clear as possible:

     

    ALL (EVERY SINGLE) of these tests are destined to throw REALLY bad timings on the Atari, running Atari Basic (or any other interpreted-level compatible substitute).

     

    WHY? Because these tests require, first and foremost, constant, direct indexed access to the data structures involved (for strings, pointers, etc.) And guess what? The access to these data structures require the use of variables on which you must manipulate their values iteratively.... And guess what? ALL of these variables are FLOATS (!!!) NONE are true integers (one or two bytes) as you should for accessing arrays, string content, etc... 

     

    Let's not even talk about the handling of strings, themselves, nor the internal run-time status of the interpreter (mostly using floats too!). The above factor alone brings in a HUGE execution penalty to ANY task you may want to carry on the Atari, with Atari Basic's puny 8KB footprint...

     

    And the worst? Well... it turns out that we all know this before running any of these stuff, but somehow insist in throwing wrenches at it !

    As I said, I never designed it to benchmark anything but my own code, I never designed it to pick on the Atari. 
    This is pretty standard code for a MS BASIC machine. 
    I sorted an index, because it's faster than sorting strings, and it could be sorted according to any field in the data statements. 
    If you want to swap strings in Atari BASIC instead, give it a try.  I'm not sure it will be any more "fair".
    If you want to use assembly... then you aren't benchmarking the BASIC anymore.
    If it doesn't work well on the Atari, it doesn't work well on the Atari.  So what? 

    Guess what?  MS BASIC uses floats for everything on the Apple II, C64, CoCo, MC-10, Plus/4, etc... to use integers, it has to convert from floats to INTs for every index.
    All addition, subtraction, multiplication, division... floats. 
    Adding a constant to a variable?  It has to be converted from ASCII a byte at a time every time the code is executed, and it converts it to... a FLOAT!
    There are no integer data types.  Not only that, but there are two types of floats.  Packed, and unpacked, which the interpreter has to convert between as it even processes floats.
    Run time status of the interpreter... you are dealing with 16 bit ints for line numbers, a few pointers, and some bytes for are we running, # of nested FOR  loops, etc... but everything else is pretty much... FLOAT.  
    I could bitch about a lot of crap in MS BASIC
    Every one of these BASICs has a huge amount of overhead that shouldn't be there. 

    The MC-10 ROM footprint... 8K for everything.  Standard Color BASIC on the CoCo?  8K for everything.
    But the Atari is soooo picked on in it's little 8K ROM space

    Part of what benchmarks do is show how one program (in this case an interpreter) is faster than another
    The goal of a benchmark isn't to optimize the piss out of it until you win.  I know it's your goal, but that's not benchmarking.
    You try to optimize the benchmark, change the benchmark, and then wonder why people say you missed the point. 

    You did the same thing with Ahl's benchmark, and I wasn't the only one to point out that's not how a benchmark works.

    Your response to Stephen (his post is 128 in that thread)... you said he was wrong because, and posted a picture of a sports car being chased by a cop.
    Well, there's a great argument
     

    38 minutes ago, Faicuai said:

    Wrong!

     

    Last time I did a PERFECT, code-to-code, byte-for-byte bench. Between the C64, Apple II and Atari, compiled with CC65, from the same C-source, with for the exact same CPU, with the exact same optimizations, guess what? You cried, too! "Oh!!! But it is 1.79 Mhz vs. X, Y, Z.."

     

    Yeah, right... 

     

     

    Last time?  I cried too?  What thread was this?  I would have said of course it's faster, same code, higher clock speed.
    But then a IIgs, Laser 128EX, and IIc Plus are faster than an Atari because they have a faster clock speed than the Atari.
    Same response, of course it's faster, same code, higher clock speed.

    But this has nothing to do with benchmarking BASIC.
     

  15. Posted

    24 minutes ago, Faicuai said:

    WoOoOoW !

     

    Bravo! Those execution timings are unbelievable...

     

    The "DESTROYER" of worlds has arrived!! 😜👍

    And it's not reading data, it's just timing the sort, it's not the same sort, compiler vs interpreter...

     

  16. Posted · Edited by JamesD

    31 minutes ago, Faicuai said:

    The bottom-line of this while discussion is:

     

    1. It is quite EASY to deliberately try / make things slower and throw surgical wrenches at X,Y,Z platform and software environments.

    2. It is, however, MUCH HARDER to deliberately make things MUCH faster, efficient, less resource-demanding, while still using the same HW-processing resources and clock speed.

     

    Whenever anyone comes to me with a benchmark test / concept, I ONLY and automatically think of #2. Any attempt to develop and evolve a discussion around point #1 is already a dead-end street, by definition, and draws little to no interest on me, in general. There are a few exceptions, depending on what are we hunting down, of course.

     

    Overall, in the case of the Atari, and when it comes to anything done in CC65 (based on #2 premise), I have found that nothing touches it on CPU-intensive work (respect to its peer group and native HW), except the BBC Micro, or anything based on Z80 running at or beyond 4 Mhz.

     

    I've complained about you tuning benchmarks before. 
    You tune the benchmark, say look how fast, and the other machines don't have the same optimizations.
    #2 is definitely an issue when you don't make the same optimizations for all machines, and I've NEVER seen you make the same optimizations for other platforms..

    You've used the CoCo 3 and a 6309 how many times?

    *edit* at least I think it was you tuning benchmarks.  I'd have to look.


     

  17. Posted

    4 minutes ago, _The Doctor__ said:

    the problem is depending on the machine and the BASIC flavor in use, line order, data position within the program, sort direction and type can favor one machine over the other.

    Each form of BASIC has their own affinities. one program favors this computer or that, this BASIC or that...

    benchmarks on most machines are supposed eliminate favoritism of any kind. this is extremely hard to do on older machines.

    Do we prohibit/inhibit graphics cards from choosing the best method to get the job done for benchmarks today? No we leave it up to each offering to handle the task in whatever way it's engine decided to organize and break down tasks to ultimately push what we want out. In fact we have had different programs to do so because at least in one period of history they had to be! Each card was so different the drivers and even the programs themselves had no choice but to be different to get the same results. All the benchmarks cared about was getting the desired result and how fast. They did not require everything to be the same in the program or drivers/code. Do we say oh no that's not fair! we must prevent the card, it's software, and firmware from making it's own strategy and in essence it's own program to get things done? If we did that very little could have ever been 'benchmarked'

    You might be able to apply the 'universal' benchmark' to today's graphics cards and processors as you are using the common interfaces of  whatever OS and graphic convention that they have homogenized into, there are like what 2 or three choices these days? and there are still behind the scenes shenanigans that people argue about for each of those benchmarks for the ATI camp vs nVidea camp vs AMD vs Intel... each time the riot act is pronounced when one claims to be better than the other and how the benchmark is flawed. It's not as bad as it used to be... but it's still going on. As a general rule the benchmarks are great over time though, each camp learns to program to speed things up, each modifies their drivers to do a better job, each works on the firmware and architecture to win the benchmark. This keeps things moving in the right direction. It's all about the end result and how fast, not about how it got there... to most users it just matters that when you go to play unreal tournament infinity.... you get it all as fast and accurate as possible so you see the enemy first and waste them before they ever knew you were there.

    My apologies but the only true benchmark is how fast can you get a thing done...

     

    By all means, show how the code order, or sort order is somehow biased against the Atari.
    Alphabetical order is alphabetical order.  How on earth would that be biased? 
    If you have some logical explanation of how this isn't brutal on Microsoft BASIC, but intentionally picks on Atari, I'd like to hear it.

    Favoritism, fairness?  I didn't even write the benchmark to compare different machines.  I wrote it as a torture test to see if my new string compare worked, and if it was any faster.  I'm pretty sure I didn't try to discriminate against Atari.

    Even with graphics cards, you have standard benchmarks that are absolute torture tests, and they run on DirectX no matter which card you have.
    So it's not like you have a completely different benchmark for each machine. 
    You have different implementations of DirectX targeting different hardware, just like you have different versions of BASIC. 
    But the benchmark is the same.
    I also think you'll find a lot of criticism over "tuning" drivers for modern benchmarks.
    Manufacturers make changes just so they get better numbers on a benchmark, but they offer no performance increase on real games.

    FWIW, I won't say you can't turn in better numbers, but don't expect to compare a BASIC compiler from 1985 against uncompiled BASIC from 1979 without getting a not so fast in response.
     

  18. Posted

    7 hours ago, drpeter said:

    Point of information/debate.  Would we call Fast Basic an interpreted BASIC?

    Yes, but it's also compiled so it doesn't have to perform any parsing, or evaluate order of operations for math on the fly.
    Most time consuming tasks like that are handled at compile time.
    While it's not native code, the overhead is significantly lower than with a regular interpreter.

  19. Posted

    Given the differences between Atari BASIC and MS BASIC, some leeway is required to even get the benchmark to run, but the code should be as close to the same as possible if we want a meaningful speed comparison. 
    That concept always seems to get thrown out the window in favor of "look how fast we can do it if we completely change the code!"
    So far the fastest way is a modern compiler where the code looks nothing like the original, or a version of BASIC that wasn't available until Dec 1985.
    I was hoping for a faster solution that could work on original Atari BASIC so it could compete better with the Apple II series in the early years.
    I say early years because the first Applesoft BASIC compiler was released 1981, and the first accelerator board in 1982, so if you want to pull out all the stops, keep in mind that becomes an option on other machines as well.

    If you want to "win" a battle, you might want to at least try to limit the time frame from 1978-1980.
    If it's not possible, then it's just not possible, but close would certainly go a long way to disprove criticism of Atari BASIC string handling.
     

    • Like 1

  21. Posted

    50 minutes ago, dmsc said:

    But note that reported times in the Atari programs above only report the sorting phase, not the reading and printing, so the "time to sort 891 strings" should be comparable.

     

    Just be aware that when I made the original read through the data twice, checked the results of the sort, and printed the results, it was intentional.
    It wasn't just about the sort.  People missed that point from the start.  I wanted a benchmark that wasn't just limited to one thing. 
    Ahl's benchmark, prime number generation, etc.. mostly deal with math. 
    I just wasn't in the mood to argue.  But the "benchmark" tuning is getting out of hand at this point.

    • Like 1

  22. Posted · Edited by JamesD

    40 minutes ago, dmsc said:

    I could have used "comb sort" to make it more comparable, but I really dislike that algorithm, as it is slower than shell sort and does not have a proof of complexity, so you don't know if it will be fast at all with your sequence. And in the way you coded in your first example, it does not warrant that the array will be sorted at all!

     

    Worst case performance is the same as quick sort.
    Best case and average depend on number of passes.  It might be the same as quick sort... or not.  :P
     

     

    9 minutes ago, jnharmon said:

    Might be interesting to use a QuickSort routine (if there is enough RAM for the pseudo-stack) to see what affect that has.

    And then you have to do QuickSort on every version.

    Why can't we use a machine language sort is the next question.

    It's not about getting to the end the fastest, it's about how long it takes to get to the end the same way.

  23. Posted · Edited by JamesD

    I hate to be nit picky, but that isn't doing even close to the same amount of work, so it's an apples and oranges comparison.
    But the sort is fast.

    *edit*
    FWIW, I think it's awesome to be able to define data like that.
     

  24. Posted · Edited by JamesD

    The MC-10 with an HD6303 should complete this somewhere around 4 minutes  (240 seconds) +-10 seconds depending on the speedup it offers here.
    I haven't modded a machine to verify % speedup yet, but the HD6309 speeds up the CoCo by around 20% in native mode with no 6309 specific code, so I guessed between 15% and 20% faster.

AtariAge
Forums
Store
General
Follow AtariAge

Copyright ©1998-2021 AtariAge

×
×
  • Create New...