`allocs/op` means how many distinct memory allocations occurred per op (single iteration). 

`B/op` is how many bytes were allocated per op.

After training a word2vec model using python [gensim](http://radimrehurek.com/gensim/models/word2vec.html), how do you find the number of words in the model&#39;s vocabulary?

gensim word2vec: Find number of words in vocabulary

I have a Java Map that I&#39;d like to transform and filter. As a trivial example, suppose I want to convert all values to Integers then remove the odd entries.

    Map&lt;String, String&gt; input = new HashMap&lt;&gt;();
    input.put(&quot;a&quot;, &quot;1234&quot;);
    input.put(&quot;b&quot;, &quot;2345&quot;);
    input.put(&quot;c&quot;, &quot;3456&quot;);
    input.put(&quot;d&quot;, &quot;4567&quot;);

    Map&lt;String, Integer&gt; output = input.entrySet().stream()
            .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    e -&gt; Integer.parseInt(e.getValue())
            ))
            .entrySet().stream()
            .filter(e -&gt; e.getValue() % 2 == 0)
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));


    System.out.println(output.toString());

This is correct and yields: `{a=1234, c=3456}`

However, I can&#39;t help but wonder if there&#39;s a way to avoid calling `.entrySet().stream()` twice.

Is there a way I can perform both transform and filter operations and call  `.collect()` only once at the end?

Transform and filter a Java Map with streams

When I run my benchmarks with `go test -v -bench=. -benchmem`, I see the following results.

    f1     10000	    120860 ns/op	    2433 B/op	      28 allocs/op
    f2	   10000	    120288 ns/op	    2288 B/op	      26 allocs/op

Based on my understanding:

 

 1. `10000` is the number of iterations `for i := 0; i &lt; b.N; i++ {`.  
 2. `XXX ns/op` is approximate time it took for one iteration to complete

But even after [reading the docs][1], I can not find out what `B/op` and `allocs/op` mean.


----------


My guess is that allocs/op has something to do with garbage collection and memory allocation (the less the better).


Can anyone give a nice explanation of the meaning of these values. Also it would be nice to know why do the go up and main steps to reduce them (I realize this is test specific, but may be there are some universal hints that work in many cases)


  [1]: https://golang.org/pkg/testing/

What does allocs/op and B/op mean in go benchmark?

When I run my benchmarks with <code>go test -v -bench=. -benchmem</code>, I see the following results.
<pre><code class="hljs language-bash">f1 10000	 120860 ns/op	 2433 B/op	 28 allocs/op
f2	 10000	 120288 ns/op	 2288 B/op	 26 allocs/op
</code></pre>
Based on my understanding:
<ol>
<li><code>10000</code> is the number of iterations <code>for i := 0; i &#x3C; b.N; i++ {</code>.</li>
<li><code>XXX ns/op</code> is approximate time it took for one iteration to complete</li>
</ol>
But even after <a href="https://golang.org/pkg/testing/" target="_blank" rel="noopener noreferrer">reading the docs</a>, I can not find out what <code>B/op</code> and <code>allocs/op</code> mean.
<hr>
My guess is that allocs/op has something to do with garbage collection and memory allocation (the less the better).
Can anyone give a nice explanation of the meaning of these values. Also it would be nice to know why do the go up and main steps to reduce them (I realize this is test specific, but may be there are some universal hints that work in many cases)

If I wanted to do the following:

    fmt.Printf(&quot;Escape this -&gt; %v... Do not escape this -&gt; %v&quot;, &quot;Unescaped&quot;)

How could I escape the first occurrence of `%v`? 

`\%v` doesn&#39;t seem to work. Any ideas?

Escape Variables with Printf

I have a custom type which internally has a slice of data.

Is it possible, by implementing some functions or an interface that the range operator needs, to iterate (using range) over my custom type?

In Go is it possible to iterate over a custom type?

There are many cases using **nil** in golang. For example:

    func (u *URL) Parse(ref string) (*URL, error) {
   		refurl, err := Parse(ref)
   		if err != nil {
   			return nil, err
   		}
   		return u.ResolveReference(refurl), nil
    }

but we can&#39;t use it like this:

    var str string //or var str int
    str = nil

the golang compiler will throw a `can&#39;t use nil as type string in assignment ` error.

Looks like `nil` can only be used for a pointer of struct and interface. If that is the case, then **what does it mean?**
and **when we use it to compare to the other object, how do they compare, in other words, how does golang determine one object is nil**?

**EDIT:For example, if an interface is nil, its type and value must be nil at the same time. How does golang do this?**

What does nil mean in golang?

From the documentation on [log.Fatalln()](https://golang.org/pkg/log/#Fatalln):


&gt; func Fatalln(v ...interface{}) Fatalln is equivalent to Println()
&gt; followed by a call to os.Exit(1).

The [source code](https://golang.org/src/log/log.go) for Fatalln:

       310	// Fatalln is equivalent to Println() followed by a call to os.Exit(1).
       311	func Fatalln(v ...interface{}) {
       312		std.Output(2, fmt.Sprintln(v...))
       313		os.Exit(1)
       314	}

It seems the main difference is whether or not the error is recoverable (since you can recover a panic) - is there anything more significantly different between these? 

Panic&#39;s interface [definition](https://golang.org/src/builtin/builtin.go?h=func+panic) is:

   

       215	// The panic built-in function stops normal execution of the current
       216	// goroutine. When a function F calls panic, normal execution of F stops
       217	// immediately. Any functions whose execution was deferred by F are run in
       218	// the usual way, and then F returns to its caller. To the caller G, the
       219	// invocation of F then behaves like a call to panic, terminating G&#39;s
       220	// execution and running any deferred functions. This continues until all
       221	// functions in the executing goroutine have stopped, in reverse order. At
       222	// that point, the program is terminated and the error condition is reported,
       223	// including the value of the argument to panic. This termination sequence
       224	// is called panicking and can be controlled by the built-in function
       225	// recover.
       226	func panic(v interface{})

It appears panic does not return anything.

Is that the primary difference? Otherwise, they seem to perform the same function in an application, assuming the panic is not recovered.

What are the differences in outcome for panic vs log.Fatalln()?

The program [available on The Go Playground][2] reads

    package main
    
    import &quot;fmt&quot;
    
    func main() {
    	var name string = nil
    	fmt.Println(name)
    }

and yields an error

    prog.go:6: cannot use nil as type string in assignment


I understand [`&quot;&quot;` is the &quot;zero value&quot; for strings][1]. I don&#39;t understand why I cannot assign `nil` to my `string`.

  [1]: https://tour.golang.org/basics/12
  [2]: https://play.golang.org/p/2gLydmLeHf

Why can&#39;t a string be nil in Go?

Consider:

    #include &lt;time.h&gt;
    #include &lt;unistd.h&gt;
    #include &lt;iostream&gt;
    using namespace std;

    const int times = 1000;
    const int N = 100000;

    void run() {
      for (int j = 0; j &lt; N; j++) {
      }
    }

    int main() {
      clock_t main_start = clock();
      for (int i = 0; i &lt; times; i++) {
        clock_t start = clock();
        run();
        cout &lt;&lt; &quot;cost: &quot; &lt;&lt; (clock() - start) / 1000.0 &lt;&lt; &quot; ms.&quot; &lt;&lt; endl;
        //usleep(1000);
      }
      cout &lt;&lt; &quot;total cost: &quot; &lt;&lt; (clock() - main_start) / 1000.0 &lt;&lt; &quot; ms.&quot; &lt;&lt; endl;
    }

Here is the example code. In the first 26 iterations of the timing loop, the `run` function costs about 0.4&amp;nbsp;ms, but then the cost reduces to 0.2&amp;nbsp;ms.

When the `usleep` is uncommented, the delay-loop takes 0.4&amp;nbsp;ms for all runs, never speeding up. Why?

The code is compiled with `g++ -O0` (no optimization), so the delay loop isn&#39;t optimized away. It&#39;s run on Intel(R) Core(TM) [i3-3220][1] CPU @ 3.30&amp;nbsp;GHz, with 3.13.0-32-generic [Ubuntu&amp;nbsp;14.04.1][2] LTS (Trusty Tahr).

  [1]: https://en.wikipedia.org/wiki/List_of_Intel_Core_i3_microprocessors#.22Ivy_Bridge.22_.2822_nm.29
  [2]: https://en.wikipedia.org/wiki/List_of_Ubuntu_releases#Ubuntu_14.04_LTS_.28Trusty_Tahr.29


Why does this delay-loop start to run faster after several iterations with no sleep?

The following Java program takes on average between 0.50 secs and 0.55 secs to run:

    public static void main(String[] args) {
        long startTime = System.nanoTime();
        int n = 0;
        for (int i = 0; i &lt; 1000000000; i++) {
            n += 2 * (i * i);
        }
        System.out.println((double) (System.nanoTime() - startTime) / 1000000000 + &quot; s&quot;);
        System.out.println(&quot;n = &quot; + n);
    }

If I replace `2 * (i * i)` with `2 * i * i`, it takes between 0.60 and 0.65 secs to run. How come?

I ran each version of the program 15 times, alternating between the two. Here are the results:

     2*(i*i)  |  2*i*i
    ----------+----------
    0.5183738 | 0.6246434
    0.5298337 | 0.6049722
    0.5308647 | 0.6603363
    0.5133458 | 0.6243328
    0.5003011 | 0.6541802
    0.5366181 | 0.6312638
    0.515149  | 0.6241105
    0.5237389 | 0.627815
    0.5249942 | 0.6114252
    0.5641624 | 0.6781033
    0.538412  | 0.6393969
    0.5466744 | 0.6608845
    0.531159  | 0.6201077
    0.5048032 | 0.6511559
    0.5232789 | 0.6544526

The fastest run of `2 * i * i` took longer than the slowest run of `2 * (i * i)`. If they had the same efficiency, the probability of this happening would be less than `1/2^15 * 100% = 0.00305%`.


Why is 2 * (i * i) faster than 2 * i * i in Java?

As part of my investigation on the difference between using a complex filter or multiple filters in streams, I notice that performance on Java 12 is way slower than on Java 8.

Is any explanation for those weird results? Did I miss something here? 

**Configuration:** 

* java 8
  * OpenJDK Runtime Environment (build 1.8.0_181-8u181-b13-2~deb9u1-b13)
  * OpenJDK 64-Bit Server VM (build 25.181-b13, mixed mode)

* java 12
  * OpenJDK Runtime Environment (build 12+33)
  * OpenJDK 64-Bit Server VM (build 12+33, mixed mode, sharing)

* VM options: `-XX:+UseG1GC` `-server` `-Xmx1024m` `-Xms1024m`
* CPU: 8 cores

**JMH Throughput Results**:

* Warmup: 10 iterations, 1 s each
* Measurement: 10 iterations, 1 s each
* Threads: 1 thread, will synchronize iterations
* Units: ops/s

[![Comparison tables][2]][2]

## Code

**Stream + complex filter**

```java
public void complexFilter(ExecutionPlan plan, Blackhole blackhole) {
        long count = plan.getDoubles()
                .stream()
                .filter(d -&gt; d &lt; Math.PI
                        &amp;&amp; d &gt; Math.E
                        &amp;&amp; d != 3
                        &amp;&amp; d != 2)
                .count();

        blackhole.consume(count);
    }
```

**Stream + multiple filters** 

```java
public void multipleFilters(ExecutionPlan plan, Blackhole blackhole) {
        long count = plan.getDoubles()
                .stream()
                .filter(d -&gt; d &gt; Math.PI)
                .filter(d -&gt; d &lt; Math.E)
                .filter(d -&gt; d != 3)
                .filter(d -&gt; d != 2)
                .count();

        blackhole.consume(count);
    }
```

**Parallel stream + complex filter** 

```java
public void complexFilterParallel(ExecutionPlan plan, Blackhole blackhole) {
        long count = plan.getDoubles()
                .stream()
                .parallel()
                .filter(d -&gt; d &lt; Math.PI
                        &amp;&amp; d &gt; Math.E
                        &amp;&amp; d != 3
                        &amp;&amp; d != 2)
                .count();

        blackhole.consume(count);
    }
```

**Parallel stream + multiple filters**

```java
public void multipleFiltersParallel(ExecutionPlan plan, Blackhole blackhole) {
        long count = plan.getDoubles()
                .stream()
                .parallel()
                .filter(d -&gt; d &gt; Math.PI)
                .filter(d -&gt; d &lt; Math.E)
                .filter(d -&gt; d != 3)
                .filter(d -&gt; d != 2)
                .count();

        blackhole.consume(count);
    }

```

**Old fashion java iteration** 

```java
public void oldFashionFilters(ExecutionPlan plan, Blackhole blackhole) {
        long count = 0;
        for (int i = 0; i &lt; plan.getDoubles().size(); i++) {
            if (plan.getDoubles().get(i) &gt; Math.PI
                    &amp;&amp; plan.getDoubles().get(i) &gt; Math.E
                    &amp;&amp; plan.getDoubles().get(i) != 3
                    &amp;&amp; plan.getDoubles().get(i) != 2) {
                count = count + 1;
            }
        }

        blackhole.consume(count);
    }

```

You can try by yourself by running docker command: 

For Java 8: 

&gt; docker run -it volkodav/java-filter-benchmark:java8

For Java 12: 

&gt; docker run -it volkodav/java-filter-benchmark:java12


**Source code:**

https://github.com/volkodavs/javafilters-benchmarks


  [2]: https://i.stack.imgur.com/GTYeu.png

Mystifying microbenchmark result for stream API on Java 12 vs. Java 8 with -gc true

When using the same code, simply changing the compiler (from a C compiler to a C++ compiler) will change how much memory is allocated. I&#39;m not quite sure why this is and would like to understand it more. So far the best response I&#39;ve gotten is &quot;probably the I/O streams&quot;, which isn&#39;t very descriptive and makes me wonder about the &quot;you don&#39;t pay for what you don&#39;t use&quot; aspect of C++.

I&#39;m using the Clang and GCC compilers, versions 7.0.1-8 and 8.3.0-6 respectively. My system is running on Debian 10 (Buster), latest. The benchmarks are done via Valgrind Massif.

```Cpp
#include &lt;stdio.h&gt;

int main() {
    printf(&quot;Hello, world!\n&quot;);
    return 0;
}
```

The code used does not change, but whether I compile as C or as C++, it changes the results of the Valgrind benchmark. The values remain consistent across compilers, however. The runtime allocations (peak) for the program go as follows:

* GCC (C): 1,032 bytes (1 KB)
* G++ (C++): 73,744 bytes, (~74 KB)
* Clang (C): 1,032 bytes (1 KB)
* Clang++ (C++): 73,744 bytes (~74 KB)

For compiling, I use the following commands:

```
clang -O3 -o c-clang ./main.c
gcc -O3 -o c-gcc ./main.c
```

```
clang++ -O3 -o cpp-clang ./main.cpp
g++ -O3 -o cpp-gcc ./main.cpp
```

For Valgrind, I run `valgrind --tool=massif --massif-out-file=m_compiler_lang ./compiler-lang` on each compiler and language, then `ms_print` for displaying the peaks.

Am I doing something wrong here?


Why is C++ initial allocation so much larger than C&#39;s?

I am reading [this book][1] by Fedor Pikus and he has some very very interesting examples which for me were a surprise.  
Particularly this benchmark caught me, where the only difference is that in one of them we use || in if and in another we use |.

    void BM_misspredict(benchmark::State&amp; state)
    {
    
    	std::srand(1);
    	const unsigned int N = 10000;;
    	std::vector&lt;unsigned long&gt; v1(N), v2(N);
    	std::vector&lt;int&gt; c1(N), c2(N);
    
    	for (int i = 0; i &lt; N; ++i) 
    	{
    		v1[i] = rand();
    		v2[i] = rand();
    		c1[i] = rand() &amp; 0x1;
    		c2[i] = !c1[i];
    	}
    
    	unsigned long* p1 = v1.data();
    	unsigned long* p2 = v2.data();
    	int* b1 = c1.data();
    	int* b2 = c2.data();
    
    	for (auto _ : state)
    	{
    		unsigned long a1 = 0, a2 = 0;
    		for (size_t i = 0; i &lt; N; ++i) 
    		{
    			if (b1[i] || b2[i])  // Only difference
    			{
    				a1 += p1[i];
    			}
    			else 
    			{
    				a2 *= p2[i];
    			}
    		}
    		benchmark::DoNotOptimize(a1);
    		benchmark::DoNotOptimize(a2);
    		benchmark::ClobberMemory();
    
    	}
    	state.SetItemsProcessed(state.iterations());
    }
    
    void BM_predict(benchmark::State&amp; state)
    {
    
    	std::srand(1);
    	const unsigned int N = 10000;;
    	std::vector&lt;unsigned long&gt; v1(N), v2(N);
    	std::vector&lt;int&gt; c1(N), c2(N);
    
    	for (int i = 0; i &lt; N; ++i)
    	{
    		v1[i] = rand();
    		v2[i] = rand();
    		c1[i] = rand() &amp; 0x1;
    		c2[i] = !c1[i];
    	}
    
    	unsigned long* p1 = v1.data();
    	unsigned long* p2 = v2.data();
    	int* b1 = c1.data();
    	int* b2 = c2.data();
    
    	for (auto _ : state)
    	{
    		unsigned long a1 = 0, a2 = 0;
    		for (size_t i = 0; i &lt; N; ++i)
    		{
    			if (b1[i] | b2[i]) // Only difference
    			{
    				a1 += p1[i];
    			}
    			else
    			{
    				a2 *= p2[i];
    			}
    		}
    		benchmark::DoNotOptimize(a1);
    		benchmark::DoNotOptimize(a2);
    		benchmark::ClobberMemory();
    
    	}
    	state.SetItemsProcessed(state.iterations());
    }

I will not go in all the details explained in the book why the latter is faster, but the idea is that hardware branch predictor is given 2 chances to misspredict in slower version and in the | (bitwise or) version. See the benchmark results below.

[![enter image description here][2]][2]

So the question is why don&#39;t we always use | instead of || in branches?

  [1]: https://www.awesomebooks.com/book/9781800208117/the-art-of-writing-efficient-programs-an-advanced?gclid=Cj0KCQiAxoiQBhCRARIsAPsvo-zwAkQ0Qv0lbj7UONYxghyovSWmjix4ZTjsS_u6yS0Bnc7ESyQWR2gaAlYEEALw_wcB
  [2]: https://i.stack.imgur.com/eRCYJ.png

Content Type	Original Author	Original Content on Stackoverflow
Question	Salvador Dali	View Question on Stackoverflow
Solution 1 - Go	Not_a_Golfer	View Answer on Stackoverflow

What does allocs/op and B/op mean in go benchmark?

Go Problem Overview

Go Solutions

Solution 1 - Go

Transform and filter a Java Map with streams

gensim word2vec: Find number of words in vocabulary

Attributions