First exercise

Author: jtguggedal

Ex1/Ex1.txt

@@ -0,0 +1,48 @@
+** Task 3:
+
+Concurrency
+	Concurrency means that a part of a program, a thread, can run independent of other part of a process that is running.
+	Often implemented using threads running on a single core machine, and is therefore not "truely" parallel,
+	but acts as if it is.
+	
+Parallelism
+	Parallelism is when processes runs in true parallel, utilising multiple processor cores.
+	 
+
+Why are multicore machines becoming more popular?
+	Because of ability for parallelism and increased efficiency when executing processes on independent processors.
+	
+What kinds of problems motivates the need for concurrent execution? (Or phrased differently: What problems do concurrency help in solving?)
+	Problems where one needs to run multiple processes at the same time. For example keeping communication with multiple clients.
+
+Does creating concurrent programs make the programmer's life easier? Harder? Maybe both? (Come back to this after you have worked on part 4 of this exercise)
+	More complicated implementation, but problems may require concurrency two work properly. So, a bit of both.
+
+What are the differences between processes, threads, green threads, and coroutines?
+	Process: the execution of a program
+	Thread: a sequence of instructions that can be executed independently by a scheduler and of other threads
+	Green thread: threads that are scheduled by VM or runtime library and not OS
+	Coroutine: differs from threads in that only one coroutine runs at the same time
+
+Which one of these do pthread_create() (C/POSIX), threading.Thread() (Python), go (Go) create?
+	phthread_create(): thread
+	threading.Thread(): thread
+	go: spawns a goroutine, which is partly thread and partly coroutine, called a "lightweight" thread.
+	
+How does pythons Global Interpreter Lock (GIL) influence the way a python Thread behaves?
+	The GIL makes sure that only one thread has access to the interpreter at the same time.
+	 
+
+With this in mind: What is the workaround for the GIL (Hint: it's another module)?
+	One can use multiprocessing as a workaround, utilizing an extra process to run additional interpreter when GIL has it locked down
+
+
+What does func GOMAXPROCS(n int) int change?:
+	GOMAXPROCS limits the number of operating system threads that can execute user-level Go code simultaneously.
+	
+	
+	
+	
+** Task 4
+	When we run the code we see that the result is "never" 0, it's some number between -1 000 000 and 1 000 000.
+	This is because there's no control over the concurrency. 

Ex1/hello_world_c

@@ -0,0 +1,34 @@
+#include <pthread.h>
+#include <stdio.h>
+
+int i = 0;
+
+
+void* inc(){
+    for(int j = 0; j < 1000000; j++){
+        i++;
+    }
+    return NULL;
+}
+
+void* dec(){
+    for (int j = 0; j < 1000000; j++){
+        i--;
+    }
+    return NULL;
+}
+
+int main(){
+      pthread_t thread_inc;
+      pthread_t thread_dec;
+
+      pthread_create(&thread_inc, NULL, inc, NULL);
+      pthread_create(&thread_dec, NULL, dec, NULL);
+
+      pthread_join(thread_inc, NULL);
+      pthread_join(thread_dec, NULL);
+
+      printf("Result: %d\n", i);
+
+      return 0;
+}

Ex1/hello_world_c.c

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.hello_world_c</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

Ex1/hello_world_c.dSYM/Contents/Info.plist

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+)
+
+var i int = 0
+
+func inc(){
+	for j := 0; j < 1000000; j++ {
+    	i++
+    }
+}
+
+func dec(){
+	for j := 0; j < 1000000; j++ {
+    	i--
+    }
+}
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	go inc()
+	go dec()
+
+	time.Sleep(100 * time.Millisecond)
+	fmt.Printf("Result: %d\n", i)
+}

Ex1/hello_world_c.dSYM/Contents/Resources/DWARF/hello_world_c

@@ -0,0 +1,24 @@
+from threading import Thread
+
+i = 0
+
+def thread_inc():
+    global i
+    for j in range(1000000):
+        i += 1
+
+def thread_dec():
+    global i
+    for p in range(1000000):
+        i -= 1
+
+def main():
+	inc = Thread(target = thread_inc, args = (),)
+	dec = Thread(target = thread_dec, args = (),)
+	inc.start()
+	dec.start()
+	inc.join()
+	dec.join()
+	print(i)
+
+main()