BlackTDN Search

sábado, 28 de janeiro de 2012

BlackTDN :: stringtst :: Harbour (win) x totvsappserver (String size overflow!)

image Baseado em memtst.prg, stringtst.prg surgiu para testar os limites definidos pela área de Tecnologia da Totvs para o tamanho máximo que uma string pode ter. Nesse novo teste totvsapp decepcionou. Não passou de 1/10.

No teste 1/10, e para appserver (build: 7.00.101202A-20110330), a última stringtst Length foi de: 1.048.572 o máximo é de 1.048.575 ( + 1: String size overflow! ).

Já no aplicativo compilado pelo harbour 3.1.0dev (Rev. 17207) no teste 10/10, a última stringtst Length foi de: 103.302.755

Podemos concluir, com esse teste:

Que harbour venceu de 10x0 contra totvsapserver e que o tamanho de uma string, em advpl, ainda é muito limitado; que, no harbour, o tamanho de uma string é limitada pelo tamanho da memória disponível e, no totvsappserver, ela é limitada via código.

Eis o código do teste:

   1: /*
   2:  * $Id: stringtst.prg
   3:  * baseado no original de: Harbour Project source code: $Id: memtst.prg 13932 2010-02-20 11:57:17Z vszakats $
   4:  * a small memory manager test code
   5:  */
   6: #define N_LOOPS      (1000*1000)
   7: #define N_MAXLOOP             10
   8: #define WHITE_SPACE         1024
   9: #define MAX_SIZE_ARRAY    100000
  10:  
  11: #ifndef HB_SYMBOL_UNUSED
  12:      #define HB_SYMBOL_UNUSED( symbol ) ( symbol := ( symbol ) )
  13: #endif
  14:  
  15: #ifdef __HARBOUR__
  16:     #include "simpleio.ch"
  17:     #include "hbmemory.ch"
  18: #else
  19:     #xcommand ?  [<list,...>] => ConOut( [ <list> ] )
  20:     #xcommand ?? [<list,...>] => ConOut( [ <list> ] )
  21:     #xtranslate hb_secondsCPU() => seconds()
  22:     #ifdef TOTVS
  23:         #include "totvs.ch"
  24:     #else
  25:         #include "protheus.ch"
  26:     #endif    
  27: #endif
  28: //-----------------------------------------------------------------------------------------------------------
  29: #ifdef __HARBOUR__
  30: procedure main()
  31:     local cCRLF        := hb_OsNewLine()
  32:     local cVersion     := VERSION()+build_mode()
  33:     local cOS          := OS()
  34: #else
  35: user function stringtst()
  36:     local cCRLF        := CRLF
  37:     local cVersion     := "TOTVS APPServer " + GetVersao(.T.,.F.) + " " + GetBuild() + " " + GetRPORelease()
  38:     local cOS          := IF( IsSrvUnix() , "Unix/Linux", "Windows" )     
  39: #endif
  40:     local dDate
  41:     local cTime
  42:     local t
  43:     local nCPUSec
  44:     local nRealSec
  45:     local nSizeArr     := 100
  46:     local cWSpace      := ""
  47:     local nfhandle
  48:     local cstringtst
  49:  
  50:     SET DATE TO BRITISH
  51:     SET CENTURY ON
  52:  
  53:     for t := 1 to N_MAXLOOP
  54:     
  55:         nRealSec    := seconds()
  56:         nCPUSec     := hb_secondsCPU()
  57:     
  58:         nfhandle    := fCreate( "stringstst" + StrZero(t,10) + ".log" )
  59:         IF ( nfhandle < 0 )
  60:              ? "Can not start a test: " + Str( t )
  61:              loop
  62:         EndIF
  63:      
  64:         dDate := date()
  65:         cTime := Time()
  66:      
  67:         ? dDate, cTime, cVersion+", "+cOS
  68:         cstringtst := dtoc( dDate ) + ", " + cTime + ", " + cVersion+", "+cOS + cCRLF
  69:         #ifndef __HARBOUR__
  70:             ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
  71:         #endif
  72:      
  73:         #ifdef __HARBOUR__
  74:              if MEMORY( HB_MEM_USEDMAX ) != 0
  75:                  ?
  76:                 cstringtst += cCRLF
  77:                 #ifndef __HARBOUR__
  78:                      ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
  79:                 #endif
  80:                 ? "Warning !!! Memory statistic enabled."
  81:                 cstringtst += "Warning !!! Memory statistic enabled." + cCRLF
  82:                 #ifndef __HARBOUR__
  83:                      ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
  84:                 #endif
  85:              endif
  86:         #endif
  87:  
  88:         nSizeArr    := Min( nSizeArr * 10 , MAX_SIZE_ARRAY )
  89:         cWSpace     += Space( WHITE_SPACE )
  90:  
  91:         ?
  92:         cstringtst += cCRLF
  93:         #ifndef __HARBOUR__
  94:              ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
  95:         #endif
  96:         
  97:         cstringtst += "Len( cWSpace ) :" + Transform( Len( cWSpace ) , "9999999999" ) + cCRLF
  98:         #ifndef __HARBOUR__
  99:              ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 100:         #endif
 101:         
 102:         cstringtst += cCRLF
 103:         #ifndef __HARBOUR__
 104:              ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 105:         #endif
 106:  
 107:         cstringtst += stringtst(@cCRLF,@t,@nSizeArr,@cWSpace)
 108:         #ifndef __HARBOUR__
 109:              ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 110:         #endif
 111:  
 112:         dDate       := date()
 113:         cTime       := Time()
 114:         nCPUSec     := hb_secondsCPU() - nCPUSec
 115:         nRealSec    := seconds() - nRealSec
 116:  
 117:         ?
 118:         cstringtst += cCRLF
 119:         #ifndef __HARBOUR__
 120:              ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 121:         #endif
 122:  
 123:         ? dDate, cTime, cVersion+", "+cOS
 124:         cstringtst += dtoc( dDate ) + ", " + cTime + ", " + cVersion+", "+cOS + cCRLF
 125:         #ifndef __HARBOUR__
 126:              ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 127:         #endif
 128:  
 129:         ?
 130:         cstringtst += cCRLF
 131:         #ifndef __HARBOUR__
 132:              ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 133:         #endif
 134:       
 135:         ? " CPU time (total):", nCPUSec, "sec."
 136:         cstringtst += " CPU time (total):" + Transform(  nCPUSec , "99999.9999999999" )  + " sec." + cCRLF
 137:         #ifndef __HARBOUR__
 138:              ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 139:         #endif
 140:          
 141:         ? "real time (total):", nRealSec, "sec."
 142:         cstringtst += "real time (total):" + Transform( nRealSec , "99999.9999999999" ) + " sec." + cCRLF
 143:         ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 144:  
 145:         fWrite( nfhandle , @cstringtst )
 146:         fWrite( nfhandle , "stringtst Length:" + Transform( Len(cstringtst) , "9999999999" ) + cCRLF )
 147:           
 148:         cstringtst := NIL
 149:  
 150:         fClose( nfhandle )
 151:  
 152:     next t
 153:  
 154:     cWSpace := NIL
 155:  
 156: Return
 157: //-----------------------------------------------------------------------------------------------------------
 158: static function stringtst(cCRLF,t,nSizeArr,cWSpace)
 159:  
 160:     local i
 161:     local a
 162:     local nCPUSec
 163:     local nRealSec
 164:     local nCRLF
 165:     local lFree := .F.
 166:     local cstringtst
 167:     
 168:     ?
 169:     cstringtst := cCRLF
 170:     #ifndef __HARBOUR__
 171:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 172:     #endif
 173:     ? "testing single large memory blocks allocation and freeing..."
 174:     cstringtst += "testing single large memory blocks allocation and freeing..."+ cCRLF
 175:     #ifndef __HARBOUR__
 176:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 177:     #endif
 178:     
 179:     ?
 180:     cstringtst += cCRLF
 181:     #ifndef __HARBOUR__
 182:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 183:     #endif
 184:     
 185:     nRealSec    := seconds()
 186:     nCPUSec     := hb_secondsCPU()
 187:  
 188:     for i := 1 to ( t * N_LOOPS )
 189:         a := cWSpace
 190:         HB_SYMBOL_UNUSED( a )
 191:         a := ""
 192:         HB_SYMBOL_UNUSED( a )
 193:         a := NIL
 194:     next i
 195:  
 196:     nCPUSec     := hb_secondsCPU() - nCPUSec
 197:     nRealSec    := seconds() - nRealSec
 198:  
 199:     ? " CPU time:", nCPUSec, "sec."
 200:     cstringtst += " CPU time:" + Transform(  nCPUSec , "99999.9999999999" )  + " sec." + cCRLF
 201:     #ifndef __HARBOUR__
 202:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 203:     #endif
 204:     
 205:     ? "real time:", nRealSec, "sec."
 206:     cstringtst += "real time:" + Transform( nRealSec , "99999.9999999999" ) + " sec." + cCRLF
 207:     #ifndef __HARBOUR__
 208:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 209:     #endif
 210:     
 211:     ?
 212:     cstringtst += cCRLF
 213:     #ifndef __HARBOUR__
 214:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 215:     #endif
 216:    
 217:     ? "testing many large memory blocks allocation and freeing..."     
 218:     ?
 219:    
 220:     cstringtst += cCRLF
 221:     #ifndef __HARBOUR__
 222:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 223:     #endif
 224:     cstringtst += "testing many large memory blocks allocation and freeing..." + cCRLF
 225:     #ifndef __HARBOUR__
 226:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 227:     #endif
 228:     
 229:     ?
 230:     cstringtst += cCRLF
 231:     #ifndef __HARBOUR__
 232:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 233:     #endif
 234:  
 235:     nRealSec    := seconds()
 236:     nCPUSec     := hb_secondsCPU()
 237:     a           := Array(nSizeArr)
 238:     nCRLF       := 0
 239:     for i := 1 to ( t * N_LOOPS )
 240:         a[ i % 100 + 1 ] := cWSpace
 241:         cstringtst += Transform( i % 100 + 1  , "9999999999" )
 242:         #ifndef __HARBOUR__
 243:              ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 244:         #endif
 245:         IF ( ( ++nCRLF % 10 ) == 0 )
 246:             cstringtst += cCRLF
 247:             #ifndef __HARBOUR__
 248:                  ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 249:             #endif
 250:         EndIF
 251:         if i % 200 == 0
 252:             cstringtst += cCRLF
 253:             #ifndef __HARBOUR__
 254:                  ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 255:             #endif
 256:             IF ( lFree )
 257:                 lFree := .F.
 258:                 afill(a,"")
 259:                 ? "Free  :",i
 260:                 cstringtst += "Free  : " + Transform( i  , "9999999999" ) + cCRLF
 261:                 #ifndef __HARBOUR__
 262:                      ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 263:                 #endif
 264:             Else
 265:                 lFree := .T.
 266:                 afill(a,cWSpace)
 267:                 ? "Alloc :",i
 268:                 cstringtst += "Alloc : " + TransForm( i  , "9999999999" ) + cCRLF
 269:                 #ifndef __HARBOUR__
 270:                      ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 271:                 #endif
 272:             EndIF
 273:             cstringtst += cCRLF
 274:             #ifndef __HARBOUR__
 275:                  ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 276:             #endif
 277:         endif
 278:     next i
 279:  
 280:     aSize( a , 0 )
 281:     a           := NIL
 282:     nCPUSec     := hb_secondsCPU() - nCPUSec
 283:     nRealSec    := seconds() - nRealSec
 284:  
 285:     ? " CPU time:", nCPUSec, "sec."
 286:     cstringtst += " CPU time:" + Transform( nCPUSec  , "99999.9999999999" )  + " sec." + cCRLF
 287:     #ifndef __HARBOUR__
 288:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 289:     #endif
 290:     
 291:     ? "real time:", nRealSec, "sec."
 292:     cstringtst += "real time:" + Transform( nRealSec  , "99999.9999999999" ) + " sec." + cCRLF
 293:     #ifndef __HARBOUR__
 294:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 295:     #endif
 296:     
 297:     ?
 298:     cstringtst += cCRLF
 299:     #ifndef __HARBOUR__
 300:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 301:     #endif
 302:  
 303:     ? "testing large memory block reallocation with intermediate allocations..."
 304:  
 305:     cstringtst += "testing large memory block reallocation with intermediate allocations..." + cCRLF
 306:     #ifndef __HARBOUR__
 307:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 308:     #endif
 309:  
 310:     ? "Warning!!! some compilers may badly fail here"
 311:  
 312:     ?
 313:     cstringtst += cCRLF
 314:     #ifndef __HARBOUR__
 315:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 316:     #endif
 317:     
 318:     cstringtst += "Warning!!! some compilers may badly fail here" + cCRLF
 319:     #ifndef __HARBOUR__
 320:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 321:     #endif
 322:  
 323:     ?
 324:     cstringtst += cCRLF
 325:     #ifndef __HARBOUR__
 326:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 327:     #endif
 328:  
 329:     IdleSleep( 2 )
 330:     
 331:     nRealSec    := seconds()
 332:     nCPUSec     := hb_secondsCPU()
 333:     nCRLF       := 0
 334:     a           := Array(0)
 335:     for i := 1 to ( t * N_LOOPS )
 336:         aadd( a, { cWSpace } )
 337:         if i%1000 == 0
 338:             ?? i
 339:             cstringtst += Transform( i  , "9999999999" )
 340:             #ifndef __HARBOUR__
 341:                  ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 342:             #endif
 343:             if ( ( ++nCRLF % 10 ) == 0 )
 344:                 cstringtst += cCRLF
 345:                 #ifndef __HARBOUR__
 346:                      ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 347:                 #endif
 348:             endif
 349:         endif
 350:     next i
 351:  
 352:     cstringtst += cCRLF
 353:     #ifndef __HARBOUR__
 354:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 355:     #endif
 356:     aSize( a , 0 )
 357:     a           := NIL
 358:     nCPUSec     := hb_secondsCPU() - nCPUSec
 359:     nRealSec    := seconds() - nRealSec
 360:  
 361:     ? " CPU time:", nCPUSec, "sec."
 362:     cstringtst += " CPU time:" + Transform( nCPUSec  , "99999.9999999999" )  + " sec." + cCRLF
 363:         #ifndef __HARBOUR__
 364:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 365:     #endif
 366:     
 367:     ? "real time:", nRealSec, "sec."
 368:     cstringtst += "real time:" + Transform( nRealSec  , "99999.9999999999" ) + " sec." + cCRLF
 369:     #ifndef __HARBOUR__
 370:          ? "stringtst Length:" , Transform( Len(cstringtst) , "9999999999" ) + cCRLF
 371:     #endif
 372:     
 373:     IdleSleep( 2 )
 374:  
 375: return( cstringtst )
 376: //-----------------------------------------------------------------------------------------------------------
 377: static procedure IdleSleep( n )
 378:     #ifdef __HARBOUR__
 379:         n += seconds()
 380:         while seconds() < n
 381:         enddo
 382:     #else
 383:         Sleep( n )
 384:     #endif
 385: return
 386: //-----------------------------------------------------------------------------------------------------------
 387: #ifndef PROTHEUS
 388:     #ifndef TOTVS
 389:         static function build_mode()
 390:         #ifdef __CLIP__
 391:            return " (MT)"
 392:         #else
 393:            #ifdef __XHARBOUR__
 394:               return iif( HB_MULTITHREAD(), " (MT)", "" ) + ;
 395:                      iif( MEMORY( HB_MEM_USEDMAX ) != 0, " (FMSTAT)", "" )
 396:            #else
 397:               #ifdef __HARBOUR__
 398:                  return iif( HB_MTVM(), " (MT)", "" ) + ;
 399:                         iif( MEMORY( HB_MEM_USEDMAX ) != 0, " (FMSTAT)", "" )
 400:               #else
 401:                  #ifdef __XPP__
 402:                     return " (MT)"
 403:                  #else
 404:                     return ""
 405:                  #endif
 406:               #endif
 407:            #endif
 408:         #endif
 409:     #endif
 410: #endif 

[]s
иαldσ dj

Um comentário:

  1. Q porra de limite carai? To ligado que vc quebra isso facinho facinho! Rs...
    Vou levar essa brincadeira para o ByYou Lee... lembra que o devorador de WS la nao decepcionou!!! Abraço

    ResponderExcluir