cs61a | UC Berkeley CS61A , Fall | Machine Learning library

The command you're using is close, but not quite right:

Since go code is organized by package, while C code is not, and since go libraries/binaries are compiled package by package, I would take the wild guess that PKGDEF has information about the go language package from which the code was compiled.

In Go a deadlock is when all existing goroutines are blocked.

Your example has a single goroutine–the main goroutine–which is blocked, hence all goroutines are blocked, hence it's a deadlock.

Note: since all goroutines are blocked, new goroutines will not (cannot) be launched (because they can only be launched from running goroutines). And if all goroutines are blocked and cannot do anything, there is no point in waiting forever for nothing. So the runtime exits.

Edit:

Your edited code where you use a sleep in main is a duplicate of this: Go channel deadlock is not happening. Basically a sleep is not a blocking forever operation (the sleep duration is finite), so a goroutine sleeping is not considered in deadlock detection.

Edit #2:

Since then you removed the sleep() but it doesn't change anything. You have 2 goroutines: the main and the one executing makeRandom(). makeRandom() is blocked and main() isn't. So not all your goroutines are blocked so it's not a deadlock.

Edit #3:

In your last example when the runtime detects the deadlock, then there is only a single goroutine still running: the main(). It's true that you launch a goroutine executing worker(), but that only prints a text and terminates. "Past" goroutines do not count, terminated goroutines also can't do anything to change the blocked state of existing goroutines. Only existing goroutines count.

The specification says:

A receive operation on a closed channel can always proceed immediately, yielding the element type's zero value after any previously sent values have been received.

I don't know why the language designers chose this design, but it's useful in practice.

Use the two-value receive statement to detect when the channel yields a zero value because the channel is closed.

According to all of your listings above, you have:

• two cores per socket
• and one socket

which means you have only two CPU cores. However, you also have:

• two threads per core

which means your two CPUs can run up to four threads simultaneously (with some potential drawbacks, but at least in most cases this should offer significantly more computing power than using two threads total).

Since that's the actual hardware limit, the fact that Go computes the number of threads to use as 4 seems correct.

(I think the reason you are counting to eight is that you are assuming that each of the "cpus" that Linux reports supports two threads. That is not the case: there are only two physical cores, but each supports two threads, so Linux reports this as four "cpus".)

m is of type []Map, so m[bucketNumber] will be of type Map, not bucket.

Change type of m to *Map and dereference when used:

This is your code, commented to highlight the problem:

In fact, your Expr class is inherited by the Name class.

When you inherit from another class, you need to call the constructor function (i.e. __init__()) of the parent class (Expr) into the child class (Name).

The frame itself is generally deleted when it is exited, which happens when you think it does, the return statement being a common case. The values that were defined in that frame can live outside of it.

The code doesn't 'look' like the below, as you suggested: