BlackTDN

Desenvolvimento :: Basic - Beginner's All-purpose Symbolic Instruction Code“Old School”

2012-01-30T10:36:00.001-02:00

Esse final de semana matei a saudade de um velho e grande amigo… o meu querido CP 400 Color .. hehehe…

Muitas noites em claro escrevendo inumeras linhas para fazer pequenos pontos na tela… pequenos jogos… e ate mesmo a ousadia de alguns graficos…

E pensar que naquela epoca…BASIC era tudo de bom e mais um pouco…

Ou como diria a dupla Thayde e Dj Hum (Que tempo bom… que nao volta nunca mais…)

Criada a partie de Fortran II E inspirada em partes em Algol 60, com adições para torna-la adequada ao time-sharing, caracteristica presente em sistemas JOSS, CORC e LISP.

C COMPUTE POSITIVE ROOT OF A

C QUADRATIC EQUATION

READ IMPUT TAPE 3, 201, A, B, C

…..

Em seguida a linguagem foi precedida de outros experimentos, como as implementações de SAP e DART (um Fortran II simplificado) DARSIMCO e DOPE. Em sua versao original o BASIC possuia apenas 15 comandos:

LET

READ

DATA

GOTO

IF-THEN

FOR-TO-STEP

END

STOP

DEF

GOSUB

RETURN

DIM

REM

Lembrando que era normal o intervalo de linhas para o desenvolvimento correr de 10 em 10 linhas, e alem disso fornecia funções como SIN (seno) e ABS (absoluto).

10 REM RESOLVE EQUACAO DO SEGUNDO GRAU 20 READ A,B,C 25 IF A=0 THEN GOTO 410 30 LET D=B*B-4*A*C 40 IF D<0 THEN GOTO 430 50 PRINT "SOLUCAO" 60 IF D=0 THEN GOTO 100 70 PRINT "PRIMEIRA SOLUCAO",(-B+SQR(D))/(2*A) 80 PRINT "SEGUNDA SOLUCAO",(-B-SQR(D))/(2*A) 90 GOTO 20 100 PRINT "SOLUCAO UNICA",(-B)/(2*A) 200 GOTO 20 410 PRINT "A DEVE SER DIFERENTE DE ZERO"

420 GOTO 20 430 PRINT "NAO HA SOLUCOES REAIS" 440 GOTO 20 490 DATA 10,20,1241,123,22,-1 500 END

ANSI BASIC

INPUT "Qual é o seu nome"; UserName$
PRINT "Hello "; UserName$
DO
   INPUT "Quantas estrelas você quer"; NumStars
   Stars$ = ""
   Stars$ = REPEAT$("*", NumStars)   
REM em MS BASIC a instrução seria Stars$ = STRING$(NumStars, "*")  
   PRINT Stars$
   DO
      INPUT "Você quer mais estrelas";  Answer$
   LOOP UNTIL Answer$ <> ""
   Answer$ = LEFT$(Answer$, 1)
LOOP WHILE  UCASE$(Answer$) = "Y"
PRINT "Adeus ";
FOR I = 1 TO 200
   PRINT UserName$; " ";
NEXT I
PRINT

Enfim, matar a saudade muitas vezes é bacana… saudades dessa epoca! Bom, mas agora vou retomar COCOA e Object-C, afinal “OverFail” retornou da Terra do Nunca pra dar continuidade nessa louca aventura pelo mundo do iOs… ah e para os usuarios do Android tem surpresa boa chegando… hehehe!

Rodrigo “OverFail”

Todos :: Marcelo D2 ft. Macaco

2012-01-30T10:24:00.000-02:00

Todos! Para los que dicen todo lo que sienten
Todos! Los que navegan a contracorriente
Toto todos! Paso firme camiliminando entre la gente
Todos! Mala malabarismo tudo pendiente
Todos! Vamonos del oxido de frente
Todos! Ritmo que nunca caen en accidente
Todos! Bitirididop no es lo mismo que junto
Todos! De de de ti depende

Para os que dizem tudo que sentem TODOS
Aqueles que não se acomodam eu disse TODOS
Levante sua voz o mundo ouvirá TODOS
Só depende da gente para melhorar pra TODOS
Não importa a sua cor religião vamos nós TODOS
Não vim pra dividir eu vim para somar pra TODOS
Porque se repartir vai ficar ruim pra TODOS

Rio de Janeiro

Todos todos

Partideiros do mundo, vamo fazer barulho "porra"

Hey hey hey hey hey hey hey hey hey hey

Oye un murmullo viene es la gente contracorriente
Porque suena diferente mundo libre lleva ley
Oye un murmullo viene es la gente contracorriente
Porque suena diferente mundo curdo lleva ley

Totototo todos

Para que a água vire vinho precisaremos de TODOS
É um de cada vez é hora de unirmos TODOS
Não quero ouro dos tolos quero ouro pra TODOS
Não ser jogado aos lobos, porque os lobos somos TODOS
Que todos somos elos da corrente TODOS
E juntos chegaremos la na frente TODOS
De fato o amor vem de dentro da gente TODOS
Se embora eu disse TODOS se embora eu disse TODOS

Baila-me baila-me pra bailante, todos!
Comuni comunicando cante, todos!
Pero mira como suena la gente, todos!
Pronto empieza pronto pronto acaba, todos!
Tirenme lo malo lo ves, comuni como lo ves, todos!
Deten deten detente, todos!
Para los que luchan sin armas de frente todos!
Dede dedede de ti depende

Funkeiros do mundo Vamo fazer barulho ''porra''

26x Hey

Oye un murmullo viene es la gente contracorriente
Porque suena diferente mundo libre lleva ley
Oye un murmullo viene es la gente contracorriente
Porque suena diferente mundo curdo lleva ley

Barcelona
Conexion Rio de Janeiro
Emitiendo todos (todos)

Partieiros do mundo, vamo fazer barulho porra

26x hey

Oye un murmullo viene es la gente contracorriente
Porque suena diferente mundo libre lleva ley
Oye un murmullo viene es la gente contracorriente
Porque suena diferente mundo curdo lleva ley

O vento sopra pra cá que a gente é bamba (4x)
Marcelo D2
Rio de janeiro
Macaco
Barcelona
O mundo é nosso, o mundo é nosso
11x TODOS

25x hey

Variations on a port | LucD notes

2012-01-30T09:22:00.000-02:00

Variations on a port | LucD notes:

'via Blog this'

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

2012-01-28T11:16:00.001-02:00

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

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round X fight)

2012-01-27T23:03:00.001-02:00

Comparando os resultados do Décimo e último teste teremos:

Harbour

27/01/2012, 09:19:08, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 10240

testing single large memory blocks allocation and freeing...

CPU time: 2.0625000000 sec.
real time: 2.1090000000 sec.

Protheus/TotvsAppServer

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 211.5468750000 sec. real time: 244.7190000000 sec.	-

Harbour	Protheus/TotvsAppServer
CPU time: 7.5156250000 sec. real time: 8.9220000000 sec.	-

Teste 10

27/01/2012, 09:23:28, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	Protheus/TotvsAppServer -
CPU time (total): 225.0312500000 sec. real time (total): 259.7660000000 sec.	-

[]s
иαldσ dj

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round IX fight)

2012-01-27T22:59:00.001-02:00

Comparando os resultados do Nono teste teremos:

Harbour

27/01/2012, 09:15:12, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 9216

testing single large memory blocks allocation and freeing...

CPU time: 1.8750000000 sec.
real time: 1.9060000000 sec.

Protheus/TotvsAppServer

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 191.5156250000 sec. real time: 221.9370000000 sec.	-

Harbour	Protheus/TotvsAppServer
CPU time: 6.6093750000 sec. real time: 7.9220000000 sec.	-

Teste 9

27/01/2012, 09:19:08, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	Protheus/TotvsAppServer -
CPU time (total): 203.9531250000 sec. real time (total): 235.7810000000 sec.	-

[]s
иαldσ dj

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round VIII fight)

2012-01-27T22:54:00.001-02:00

Comparando os resultados do Oitavo teste teremos:

Harbour

27/01/2012, 09:11:43, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 8192

testing single large memory blocks allocation and freeing...

CPU time: 1.6406250000 sec.
real time: 1.6880000000 sec.

Protheus/TotvsAppServer

27/01/2012, 10:35:24, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows

Len( cWSpace ) : 8192

testing single large memory blocks allocation and freeing...

CPU time: 4.2500000000 sec.
real time: 4.2500000000 sec.

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 170.0156250000 sec. real time: 196.5940000000 sec.	CPU time: 191.5000000000 sec. real time: 191.5000000000 sec.

Harbour	Protheus/TotvsAppServer
CPU time: 6.1562500000 sec. real time: 7.0000000000 sec.	-

PLEASE, CONTACT TOTVS TECHNOLOGY DEPARTMENT.

Teste 8

27/01/2012, 09:15:12, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	Protheus/TotvsAppServer -
CPU time (total): 181.7656250000 sec. real time (total): 209.3130000000 sec.	-

[]s
иαldσ dj

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round VII fight)

2012-01-27T22:47:00.001-02:00

Comparando os resultados do Sétimo teste teremos:

Harbour

27/01/2012, 09:08:38, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 7168

testing single large memory blocks allocation and freeing...

CPU time: 1.4531250000 sec.
real time: 1.4840000000 sec.

Protheus/TotvsAppServer

27/01/2012, 10:29:34, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows

Len( cWSpace ) : 7168

testing single large memory blocks allocation and freeing...

CPU time: 3.7190000000 sec.
real time: 3.7190000000 sec.

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 149.0625000000 sec. real time: 172.1410000000 sec.	CPU time: 167.2810000000 sec. real time: 167.2810000000 sec.

Harbour	Protheus/TotvsAppServer
CPU time: 5.1406250000 sec. real time: 6.7810000000 sec.	CPU time: 179.0310000000 sec. real time: 179.0310000000 sec.

AQUI APPSRV começou a sentir o Peso do Teste

Teste 7

27/01/2012, 09:11:43, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	27/01/2012, 10:35:24, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows
CPU time (total): 159.5781250000 sec. real time (total): 184.4060000000 sec.	CPU time (total): 350.3750000000 sec. real time (total): 350.3750000000 sec.

[]s
иαldσ dj

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round VI fight)

2012-01-27T22:41:00.001-02:00

Comparando os resultados do Sexto teste teremos:

Harbour

27/01/2012, 09:06:00, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 6144

testing single large memory blocks allocation and freeing...

CPU time: 1.2187500000 sec.
real time: 1.2660000000 sec.

Protheus/TotvsAppServer

27/01/2012, 10:26:48, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows

Len( cWSpace ) : 6144

testing single large memory blocks allocation and freeing...

CPU time: 3.1880000000 sec.
real time: 3.1880000000 sec.

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 127.5781250000 sec. real time: 147.6250000000 sec.	CPU time: 144.4060000000 sec. real time: 144.4060000000 sec.

Harbour	Protheus/TotvsAppServer
CPU time: 4.6406250000 sec. real time: 5.9690000000 sec.	CPU time: 17.5150000000 sec. real time: 17.5150000000 sec.

Teste 6

27/01/2012, 09:08:38, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	27/01/2012, 10:29:34, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows
CPU time (total): 137.4062500000 sec. real time (total): 158.8750000000 sec.	CPU time (total): 165.2650000000 sec. real time (total): 165.2650000000 sec.

[]s
иαldσ dj

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round V fight)

2012-01-27T22:34:00.001-02:00

Comparando os resultados do Quinto teste teremos:

Harbour

27/01/2012, 09:03:44, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 5120

testing single large memory blocks allocation and freeing...

CPU time: 1.0156250000 sec.
real time: 1.0630000000 sec.

Protheus/TotvsAppServer

27/01/2012, 10:24:30, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows

Len( cWSpace ) : 5120

testing single large memory blocks allocation and freeing...

CPU time: 2.6560000000 sec.
real time: 2.6560000000 sec.

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 106.5937500000 sec. real time: 126.0470000000 sec.	CPU time: 120.5780000000 sec. real time: 120.5780000000 sec.

Harbour	Protheus/TotvsAppServer
CPU time: 3.8906250000 sec. real time: 4.3900000000 sec.	CPU time: 14.5940000000 sec. real time: 14.5940000000 sec.

Teste 5

27/01/2012, 09:06:00, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	27/01/2012, 10:26:48, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows
CPU time (total): 115.4375000000 sec. real time (total): 135.5160000000 sec.	CPU time (total): 137.9850000000 sec. real time (total): 137.9850000000 sec.

[]s
иαldσ dj

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round IV fight)

2012-01-27T22:30:00.001-02:00

Comparando os resultados do Quarto teste teremos:

Harbour

27/01/2012, 09:01:57, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 4096

testing single large memory blocks allocation and freeing...

CPU time: 0.8125000000 sec.
real time: 0.8430000000 sec.

Protheus/TotvsAppServer

27/01/2012, 10:22:40, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows

Len( cWSpace ) : 4096

testing single large memory blocks allocation and freeing...

CPU time: 2.1250000000 sec.
real time: 2.1250000000 sec.

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 85.4687500000 sec. real time: 99.2340000000 sec.	CPU time: 96.2030000000 sec. real time: 96.2030000000 sec.

Harbour	Protheus/TotvsAppServer
CPU time: 2.9843750000 sec. real time: 3.4220000000 sec.	CPU time: 11.5940000000 sec. real time: 11.5940000000 sec.

Teste 4

27/01/2012, 09:03:44, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	27/01/2012, 10:24:30, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows
CPU time (total): 93.2500000000 sec. real time (total): 107.5150000000 sec.	CPU time (total): 110.0780000000 sec. real time (total): 110.0780000000 sec.

[]s
иαldσ dj

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round III fight)

2012-01-27T22:24:00.001-02:00

Comparando os resultados do Terceiro teste teremos:

Harbour

27/01/2012, 09:00:35, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 3072

testing single large memory blocks allocation and freeing...

CPU time: 0.6250000000 sec.
real time: 0.6400000000 sec.

Protheus/TotvsAppServer

27/01/2012, 10:21:18, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows

Len( cWSpace ) : 3072

testing single large memory blocks allocation and freeing...

CPU time: 1.5940000000 sec.
real time: 1.5940000000 sec.

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 63.7187500000 sec. real time: 74.7820000000 sec.	CPU time: 72.0780000000 sec. real time: 72.0780000000 sec.

Harbour	Protheus/TotvsAppServer
CPU time: 2.2031250000 sec. real time: 2.6250000000 sec.	CPU time: 8.6560000000 sec. real time: 8.6560000000 sec.

Teste 3

27/01/2012, 09:01:57, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	27/01/2012, 10:22:40, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows
CPU time (total): 70.5468750000 sec. real time (total): 82.0470000000 sec.	CPU time (total): 82.4530000000 sec. real time (total): 82.4530000000 sec.

[]s
иαldσ dj

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round II fight)

2012-01-27T22:17:00.001-02:00

Comparando os resultados do Segundo teste teremos:

Harbour

27/01/2012, 08:59:56, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 2048

testing single large memory blocks allocation and freeing...

CPU time: 0.3906250000 sec.
real time: 0.4220000000 sec.

Protheus/TotvsAppServer

27/01/2012, 10:20:20, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows

Len( cWSpace ) : 2048

testing single large memory blocks allocation and freeing...

CPU time: 1.0620000000 sec.
real time: 1.0620000000 sec.

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 27.8437500000 sec. real time: 32.2030000000 sec.	CPU time: 50.8750000000 sec. real time: 50.8750000000 sec.

Harbour	Protheus/TotvsAppServer
CPU time: 1.4843750000 sec. real time: 1.7500000000 sec.	CPU time: 5.7190000000 sec. real time: 5.7190000000 sec.

Teste 2

27/01/2012, 09:00:35, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	27/01/2012, 10:21:18, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows
CPU time (total): 33.6406250000 sec. real time (total): 38.3910000000 sec.	CPU time (total): 57.7810000000 sec. real time (total): 57.7810000000 sec.

[]s
иαldσ dj

BlackTDN :: a small memory manager test code (Harbour vs AppServer : round I fight)

2012-01-27T22:00:00.001-02:00

Em 27/01/2012, 10:19:52, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows teve um desempenho mais que aceitável no teste de gerenciamento de memória e de processamento ao usar o algoritmo desenvolvido por um dos colaboradores do Harbour Project, vszakats. O algoritmo, desenvolvido orginalmente para testar o gerenciamento de memória pelo próprio Harbour, foi modificado e adaptado para compilar e rodar tanto no Harbour quando no TotvsApp.

É um algoritmo de certa forma interessante pois usa um “buffer” de 1024 bytes para testar Strings e Arrays com muitos elementos (os dois maiores consumidores de memória depois dos objetos) para testar, além do desempenho da aplicação, a alocação e liberação de memória dinâmica.

Na nova versão do código foram implementados 10 testes, dos quais o TotvsAppServer executou satisfatoriamente quase 8.

“a small memory manager test code”

#define N_LOOPS                                                                                                              (1000*1000)
#define N_MAXLOOP                                                                                                                     10
#defineWHITE_SPACE                                                                                                                1024
#defineMAX_SIZE_ARRAY                                                                                                       100000

Aos resultados:

Usando o WinMerge para comparar o conteúdo dos diretórios poderemos perceber que Harbour executou 10 dos 10 testes definidos.

Com isso, podemos concluir que o Harbour teve mais folego na execução dos testes e possuindo gerenciamento de memória e “Garbage Collector” mais eficientes, não desmerecendo o TotvsAppServer que enviou mensagens bem informativas e esclarecedoras sobre o processo de Gerenciamento de Memória:

----------- OS Memory Summary -------------
Physical memory . 2035.77 MB. Used 2022.23 MB. Free 13.54 MB.
Paging file ..... 3927.52 MB. Used 2816.35 MB. Free 1111.17 MB.

----------- APP Memory Summary ------------
       Service Memory Capacity ...      2047.88 MB.
       Service Virtual Address ...         1944.62 MB.
       Service Resident Memory ...      1917.86 MB.

[FATAL][SERVER] [MEMORY] Used memory OVER SAFE LIMIT. REMOTE CONNECTIONS ARE DISABLED.

[INFO ][SERVER] [MEMORY] VMA Avg 0.90 - Peak 1844.74 MB. - SL 2047.88 MB.

[INFO ][SERVER] [MEMORY] RES Avg 1.00 - Peak 1818.76 MB. - SL 1818.76 MB.

Comparando os resultados do Primeiro teste teremos:

Harbour

27/01/2012, 08:59:36, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3

Len( cWSpace ) : 1024

testing single large memory blocks allocation and freeing...

CPU time: 0.2031250000 sec.
real time: 0.2190000000 sec.

Protheus/TotvsAppServer

27/01/2012, 10:19:52, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows

Len( cWSpace ) : 1024

testing single large memory blocks allocation and freeing...

CPU time: 0.5310000000 sec.
real time: 0.5310000000 sec.

testing many large memory blocks allocation and freeing...

testing large memory block reallocation with intermediate allocations...

Harbour	Protheus/TotvsAppServer
CPU time: 13.1093750000 sec. real time: 14.9690000000 sec.	CPU time: 24.3600000000 sec. real time: 24.3600000000 sec.

Harbour	Protheus/TotvsAppServer
CPU time: 0.7187500000 sec. real time: 0.8120000000 sec.	CPU time: 2.8440000000 sec. real time: 2.8440000000 sec.

Teste 1

27/01/2012, 08:59:56, Harbour 3.1.0dev (Rev. 17207), Windows XP 5.1.2600 Service Pack 3	27/01/2012, 10:20:20, TOTVS APPServer P10 7.00.101202A-20110330 R1, Windows
CPU time (total): 18.0156250000 sec. real time (total): 20.0000000000 sec.	CPU time (total): 28.0000000000 sec. real time (total): 28.0000000000 sec.

[]s
иαldσ dj

BlackTDN :: TotvsAppServer : Memory Allocation Failure

2012-01-27T10:10:00.001-02:00

[FATAL][SERVER] [Thread 3808] [THROW] Memory Allocation Failure ( 39577972 bytes ) at file c:\advtec9_101202a\lib_base\list.hpp line 794
/*-------------------------------------------------------
ERRO THREAD ([3808], marinaldo.jesus, NALDO-PC)   27/01/2012   09:59:32

 Stack : 
Memory Allocation Failure ( 39577972 bytes ) in file c:\advtec9_101202a\lib_base\list.hpp at line 794 on MEMTST(MEMTST.PRG) 26/01/2012 23:36:48 line : 232

[build: 7.00.101202A-20110330]
[environment: ndj_01]
[thread: 3808]
[rpodb: SQL]
[localfiles: ADS]
[remark: ]
[threadtype: RmtSockThread]
Called from U_MEMTST(MEMTST.PRG) 26/01/2012 23:36:48 line : 91
-------------------------------------------------------*/

[INFO ][SERVER] [MEMORY][27/01/2012 09:59:34] Used memory average CRITICAL.

----------- Total Thread Count ------------
                 Total Threads ... 17
                        Thread ... 2
                       WThread ... 9
                 RmtSockThread ... 1
                    SockServer ... 1
                      VtThread ... 3
                      VtServer ... 1

----------- Detailed Thread List ----------
[      3808][    0.00 MB]	marinaldo.jesus	NALDO-PC		U_MEMTST	ndj_01	Fri Jan 27 09:39:18 2012	00:20:16	394828994	64014		[]
----------- Detailed Process List ----
[      2056][    0.00 MB][         Thread][ tMemoryMonitor][]
[      4088][    0.00 MB][       VtServer][       VtServer][]
[      6096][    0.00 MB][       VtThread][     tVTWThread][]
[      5776][    0.00 MB][       VtThread][     tVTWThread][]
[      1792][    0.00 MB][       VtThread][     tVTWThread][]
[      4576][    0.00 MB][     SockServer][    tMainServer][]
[      5972][    0.00 MB][        WThread][   tWThreadBase][]
[      5768][    0.00 MB][        WThread][   tWThreadBase][]
[      5588][    0.00 MB][        WThread][   tWThreadBase][]
[      5316][    0.00 MB][        WThread][   tWThreadBase][]
[      1440][    0.00 MB][        WThread][   tWThreadBase][]
[      5488][    0.00 MB][        WThread][   tWThreadBase][]
[      4468][    0.00 MB][        WThread][   tWThreadBase][]
[       672][    0.00 MB][        WThread][   tWThreadBase][]
[      5164][    0.00 MB][        WThread][   tWThreadBase][]
[      3312][    0.00 MB][         Thread][    tJobManager][]

----------- Global List Info --------------
                 IMAP Glb List ...        0.00 KB. Count 0
             Variable Glb List ...        0.00 KB. Count 0
              Session Glb List ...        0.00 KB. Count 0
                   SymTab List ...      469.94 KB. Count 29929


----------- SmartHeap Pools Info ----------
                  ctSimplePool ...        3.98 Kb. Count 0
                     ctDtmPool ...        3.98 Kb. Count 0
                ctIntervalPool ...        3.98 Kb. Count 0
                   decimalPool ...        3.98 Kb. Count 0
                    stringPool ...   124073.67 Kb. Count 7925224
                  rContentPool ...   619572.67 Kb. Count 15833052
                  namedVarPool ...       71.95 Kb. Count 248
                  instrVarPool ...   495406.98 Kb. Count 15831990
                       sumPool ...       75.94 Kb. Count 503
                   comparePool ...       75.94 Kb. Count 51
                  asnParamPool ...        3.98 Kb. Count 0
                  localEnvPool ...       71.95 Kb. Count 16
                   interFCPool ...       75.94 Kb. Count 25
                  directFCPool ...       75.94 Kb. Count 181
                inter4GLFCPool ...        3.98 Kb. Count 0
                   prgCodePool ...     6090.47 Kb. Count 18766
                   asnBasePool ...       75.94 Kb. Count 456
               ctCodeBlockPool ...       75.94 Kb. Count 4
                ctCodeBlockEnv ...       71.95 Kb. Count 1
                ctCodeBlockRef ...       71.95 Kb. Count 3
              ctCodeBlockInstr ...       71.95 Kb. Count 3
           ctAPXmlDocInterface ...        3.98 Kb. Count 0
                   ctClassData ...      139.92 Kb. Count 733
                   ctAPXmlItem ...        3.98 Kb. Count 0
             ctPrgFunctXRefEle ...      331.88 Kb. Count 12759
                  ctIdentifier ...       75.94 Kb. Count 6
             ctNamedVarXVarRef ...       75.94 Kb. Count 695
                  ctParmDefDet ...       75.94 Kb. Count 554
                     ctVarList ...   433442.13 Kb. Count 7915617
                    ctStatList ...      139.92 Kb. Count 52
                       ctConst ...       75.94 Kb. Count 1042
                ctCreateVarAbs ...        3.98 Kb. Count 0
                    ctParmList ...       75.94 Kb. Count 163
                ctArrayElement ...       75.94 Kb. Count 2
                      ctBaseIf ...       75.94 Kb. Count 54
                      ctMethod ...      139.92 Kb. Count 1135
                  ctFindObject ...       71.95 Kb. Count 2
                     ctSelfVar ...       71.95 Kb. Count 1
                   ctClassProp ...       71.95 Kb. Count 1
               ctClassInstance ...        3.98 Kb. Count 0
                  ctMethodCall ...        3.98 Kb. Count 0
                      ctReturn ...       75.94 Kb. Count 23
                   ctStaticEnv ...       75.94 Kb. Count 23
                  ctPrivateEnv ...       71.95 Kb. Count 17
           Default Memory Pool ...   257337.05 Kb. Count 15923586

           TOTAL POOLED MEMORY ...  1938505.08 Kb.


----------- OS Memory Summary -------------
Physical memory .     2035.77 MB.   Used     2031.42 MB.   Free        4.35 MB.
Paging file .....     3927.52 MB.   Used     2629.15 MB.   Free     1298.37 MB.

----------- APP Memory Summary ------------
       Service Memory Capacity ...      2047.88 MB.
       Service Virtual Address ...      1946.66 MB.
       Service Resident Memory ...      1918.40 MB.


[FATAL][SERVER] [MEMORY] Used memory OVER SAFE LIMIT. REMOTE CONNECTIONS ARE DISABLED.
[INFO ][SERVER] [MEMORY] VMA Avg   0.95 - Peak  1946.66 MB. - SL  2047.88 MB.

[INFO ][SERVER] [MEMORY] RES Avg   1.00 - Peak  1918.40 MB. - SL  1918.40 MB.
//=====================================================


Exception code: C0000005 ACCESS_VIOLATION


Fault address:  1002F894 01:0002E894 d:\totvs\p10\ndj\appserver\apwinnt.dll




Call stack:


Address   Frame


1002F894  0190C648  


Call stack:


Address   Frame     Logical addr  Module






[WARN ][SERVER] [Thread 3808] [27/01/2012 10:01:47] Erro na finalização da Thread (marinaldo.jesus, NALDO-PC) ********************************************
*** THREAD 3808 : UNEXPECTED EXCEPTION FOUND
*** tRmtServer::RMS_REMOTESTARTED
********************************************
PLEASE, CONTACT TOTVS TECHNOLOGY DEPARTMENT.


****************************************
*** Stack Overflow found *** 
*** theThreadProc -DoExecute() *** 
****************************************