Path: csiph.com!aioe.org!.POSTED!not-for-mail
From: Rod Pemberton <NoHaveNotOne@bcczxcfre.cmm>
Newsgroups: comp.lang.forth
Subject: Re: Ruby/Forth challenge for WJ
Date: Wed, 13 Jan 2016 05:21:58 -0500
Organization: Aioe.org NNTP Server
Lines: 176
Message-ID: <20160113052158.07176e0d@_>
References: <35f4686c-f2c4-4ed8-9c46-2238645b9b97@googlegroups.com> <bc6bdd0a-7fb5-4e09-9cb4-ec98a805ac82@googlegroups.com> <6e01edb6-e936-4418-bb77-e2ef9369a339@googlegroups.com> <87si22mj3x.fsf@jester.gateway.pace.com> <87oacqmilx.fsf@jester.gateway.pace.com>
NNTP-Posting-Host: n4wpt9zq8xR26Ttf9mo2BA.user.gioia.aioe.org
Mime-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
X-Complaints-To: abuse@aioe.org
X-Notice: Filtered by postfilter v. 0.8.2
X-Newsreader: Claws Mail 3.13.1 (GTK+ 2.24.10; x86_64-unknown-linux-gnu)
Xref: csiph.com comp.lang.forth:44819

On Tue, 12 Jan 2016 16:24:42 -0800
Paul Rubin <no.email@nospam.invalid> wrote:

> Paul Rubin <no.email@nospam.invalid> writes:

> >> with my 32 bit native code generating forth I get 983 ms on the
> >> same laptop  
> > Interestingly, your 32 bit Forth is beating 64 bit C++ by a wide
> > margin, even with C++ running on a considerably faster machine
> > (i7-3770).  
> 
> Oh never mind, with optimization off and subscript checking on, I was
> getting about 1 sec (GCC 4.7.2).  With optimization -O3 and unsafe
> subscripts, I get 141 ms.  This is just for the counting part, not the
> random initialization, which depends considerably on which PRNG you
> use. The subscript checking actually only makes a tiny difference.
> 
> ================================================================
> 
> #include <iostream>
> #include <random>
> #include <array>
> #include <cstdint>
> #include <chrono>
> 
> const int Bufsize = 1<<28;
> std::array<std::uint8_t, Bufsize+3> buf;
> 
> void init_array()
> {
>   std::minstd_rand rd;
>   for (int i = 0; i < buf.size(); i += 3)
>     {
>       int r = rd();
>       buf[i] = r&0xff;
>       r >>= 8; 
>       buf[i+1] = r&0xff;
>       r >>= 8; 
>       buf[i+2] = r&0xff;
>     }
>  }
> 
> int main(int argc, char **argv) {
>   auto t0 = std::chrono::high_resolution_clock::now();
>   init_array();
>   auto t1 = std::chrono::high_resolution_clock::now();
> 
>   static std::array<std::uint32_t, 256> counts;
>   for (uint8_t b: buf) {
>     ++counts[b];
>   }
>   auto t2 = std::chrono::high_resolution_clock::now();
>   std::chrono::duration<double> d1 = t1 - t0;
>   std::chrono::duration<double> d2 = t2 - t1;
>   std::cout << d1.count () << " " << d2.count() << std::endl;
>   return 0;  
> }

Shouldn't r be unsigned?

Why didn't you use 'unsigned char' for buf?

I'm not familiar with C++, but I suspect 'i<buf.size()'
returns 'Bufsize+3'.  Don't you want 'Bufsize' returned?

I used to use 'char **argv' instead of 'char *argv[]' for
many years also.  It's not technically valid for C,
perhaps it is for C++.  You didn't use them.  So, 'void'.


Are the results of your app in seconds?
 (g++ -std=c++11 -O2)

# ./pr
0.660104 0.436355

# ./pr
0.669993 0.436285

# ./pr
0.659609 0.43627

The results are going to be processor speed dependent.

If I attempt to convert your C++ code to ANSI C,
knowing very little about C++, the times come out
rather different:

# ./pr
1.016804   0.000000

# ./pr
0.926480   0.000000

# ./pr
1.002100   0.000000

All of the time is front loaded.

I would expect the times to be somewhat similar
but, I had to use one non-ANSI, Linux time function
which I've never used before.

I.e., if the counts aren't taking much time in C,
I'd wonder why C++ took so long.  Or, why C++ was
so much faster with the array initialization than
C was.

Perhaps, I made a mistake porting somewhere.  Or,
maybe there is some difference with the values
returned by the time functions?  Maybe, -O2 optimized
away the unused counts loop for C, but kept it for
C++?  Well, take a look or run it, if interested:

/* LINUX only, almost ANSI C */
/* for 32-bit or 64-bit */

#include <stdio.h> /* printf */
#include <stdlib.h> /* srand rand */
#include <time.h> /* time clock_gettime */

#define CNT 256
#define BUF 268435456UL
#define BIL 1000000000UL

unsigned char buf[BUF+3];

void init_array(void)
{
  int i,r;

  srand(time(0));

  for(i=0;i<BUF;i+=3)
  {
    r=rand();
    buf[i]=r&0xff;
    r>>=8;
    buf[i+1]=r&0xff;
    r>>=8;
    buf[i+2]=r&0xff;
  }
}

int main(void)
{
  unsigned int counts[CNT];
  unsigned long i;
  struct timespec tim0,tim1,tim2;
  unsigned long long t0,t1,t2;

  /* memset */
  for(i=0;i<CNT;i++);
    counts[i]=0;

  clock_gettime(CLOCK_MONOTONIC,&tim0);
  init_array();
  clock_gettime(CLOCK_MONOTONIC,&tim1);

  for(i=0;i<BUF;i++)
    counts[buf[i]]++;

  clock_gettime(CLOCK_MONOTONIC,&tim2);

  t0=tim0.tv_sec*BIL+tim0.tv_nsec;
  t1=tim1.tv_sec*BIL+tim1.tv_nsec;
  t2=tim2.tv_sec*BIL+tim2.tv_nsec;

  printf("%10.6f %10.6f\n",((double)(t1-t0))/BIL,((double)(t2-t1))/BIL);

return(0);
}


Rod Pemberton