{"id":213,"date":"2020-01-03T09:10:44","date_gmt":"2020-01-03T09:10:44","guid":{"rendered":"https:\/\/www.samarthya.me\/wps\/?p=213"},"modified":"2020-01-03T10:13:34","modified_gmt":"2020-01-03T10:13:34","slug":"concurrency-golang","status":"publish","type":"post","link":"https:\/\/blog.samarthya.me\/wps\/2020\/01\/03\/concurrency-golang\/","title":{"rendered":"Concurrency – GOLANG"},"content":{"rendered":"

Concurrency and Parallelism – (Helpful link<\/a>)<\/h1>\n

Last few weeks have been interesting, a new year just embarked, my learning pace slowed down; comparatively due to the festivities and obligations around, but I am still trying to maintain.<\/p>\n

This week\u00a0 tried another exercise from exercism.io. <\/a>If you have not seen this site, I recommend it highly. It is just a fun way of keeping yourself engaged in learning and trying out exercises, and all the while engaging with fellow programmers or mentors.<\/p>\n

This exercise, was about, counting the occurrence of characters in a string and trying to do it parallel<\/a>. The solution I wrote for it, is as under and will be explaining in detail.<\/p>\n

package<\/span> letter\r\n\r\nimport<\/span> \"sync\"<\/span>\r\n\r\n\/\/ FreqMap records the frequency of each rune in a given text.<\/span>\r\ntype<\/span> FreqMap map<\/span>[<\/span>rune<\/span>]<\/span>int<\/span>\r\n\r\ntype<\/span> SafeMap struct<\/span> {<\/span>\r\n\tval  FreqMap\r\n\tlock sync.<\/span>Mutex\r\n}<\/span>\r\n\r\nfunc<\/span> (<\/span>sm *<\/span>SafeMap)<\/span> Increment<\/span>(<\/span>e rune<\/span>)<\/span> {<\/span>\r\n\tsm.<\/span>lock.<\/span>Lock<\/span>(<\/span>)<\/span>\r\n\tsm.<\/span>val[<\/span>e]<\/span>++<\/span>\r\n\tsm.<\/span>lock.<\/span>Unlock<\/span>(<\/span>)<\/span>\r\n}<\/span>\r\n\r\n\/\/ Frequency counts the frequency of each rune in a given text and returns this<\/span>\r\n\/\/ data as a FreqMap.<\/span>\r\nfunc<\/span> Frequency<\/span>(<\/span>s string<\/span>)<\/span> FreqMap {<\/span>\r\n\tm :=<\/span> FreqMap{<\/span>}<\/span>\r\n\tfor<\/span> _<\/span>,<\/span> r :=<\/span> range<\/span> s {<\/span>\r\n\t\tm[<\/span>r]<\/span>++<\/span>\r\n\t}<\/span>\r\n\treturn<\/span> m\r\n}<\/span>\r\n\r\nfunc<\/span> ParallelFreq<\/span>(<\/span>s string<\/span>,<\/span> sm *<\/span>SafeMap,<\/span> wg *<\/span>sync.<\/span>WaitGroup)<\/span> {<\/span>\r\n\tfor<\/span> _<\/span>,<\/span> r :=<\/span> range<\/span> s {<\/span>\r\n\t\tsm.<\/span>Increment<\/span>(<\/span>r)<\/span>\r\n\t}<\/span>\r\n\r\n\tif<\/span> wg !=<\/span> nil<\/span> {<\/span>\r\n\t\twg.<\/span>Done<\/span>(<\/span>)<\/span>\r\n\t}<\/span>\r\n}<\/span>\r\n\r\nfunc<\/span> ConcurrentFrequency<\/span>(<\/span>elements [<\/span>]<\/span>string<\/span>)<\/span> FreqMap {<\/span>\r\n\tvar<\/span> sm SafeMap\r\n\r\n\tvar<\/span> wg sync.<\/span>WaitGroup\r\n\r\n\tsm.<\/span>val =<\/span> FreqMap{<\/span>}<\/span>\r\n\r\n\twg.<\/span>Add<\/span>(<\/span>len<\/span>(<\/span>elements)<\/span>)<\/span>\r\n\tfor<\/span> _<\/span>,<\/span> r :=<\/span> range<\/span> elements {<\/span>\r\n\t\tgo<\/span> ParallelFreq<\/span>(<\/span>r,<\/span> &<\/span>sm,<\/span> &<\/span>wg)<\/span>\r\n\t}<\/span>\r\n\twg.<\/span>Wait<\/span>(<\/span>)<\/span>\r\n\r\n\treturn<\/span> sm.<\/span>val\r\n}<\/span><\/code><\/pre>\n
The challenge was to do counting in parallel.<\/p><\/blockquote>\n
Concurrency vs Parallel<\/h2>\n
What do we understand by concurrency and is it just another word for parallel execution?<\/p>\n
They are related but not the same thing.<\/p><\/blockquote>\n
Concurrency is about DEALING with lots of things at once, it is about structure.<\/p>\n
Parallelism is about DOING lots of things at once, it is about execution.<\/p>\n
GoRoutine<\/h3>\n
A goroutine<\/strong> is a function that is capable of running concurrently with other functions. To create a goroutine<\/strong> we use the keyword go<\/code> followed by a function invocation:<\/p>\n
Step 1<\/h2>\n
Defining the structure for storing the count and the letter.<\/p>\n
type<\/span> FreqMap<\/strong> map<\/span>[<\/span>rune<\/span>]<\/span>int<\/span>\r\n\r\ntype<\/span> SafeMap<\/strong> struct<\/span> {<\/span>\r\n\tval  FreqMap\r\n\tlock sync.<\/span>Mutex\r\n}<\/span><\/code><\/pre>\n
TYPE: FreqMap<\/h2>\n
FreqMap<\/strong> allows you to define a map of rune and int. E.g. { {‘a’, 2}, {‘b’, 1}…}<\/p>\n
STRUCT: SafeMap<\/h2>\n
SafeMap<\/strong> allows you to extend the basic type FreqMap<\/strong> and add the synchronization behavior, as it will be used by multiple go routines in parallel.<\/p>\n
Method: Parallel Counting – ParallelFreq<\/span><\/code><\/h2>\n
In order to utilize the parallel counting I defined a method that utilizes the objects from sync:module of golang.<\/p>\n
func<\/span> ParallelFreq<\/span>(<\/span>s string<\/span>,<\/span> sm *<\/span>SafeMap,<\/span> wg *<\/span>sync.<\/span>WaitGroup)<\/span> {<\/span>\r\n\tfor<\/span> _<\/span>,<\/span> r :=<\/span> range<\/span> s {<\/span>\r\n\t\tsm.<\/span>Increment<\/span>(<\/span>r)<\/span>\r\n\t}<\/span>\r\n\r\n\tif<\/span> wg !=<\/span> nil<\/span> {<\/span>\r\n\t\twg.<\/span>Done<\/span>(<\/span>)<\/span>\r\n\t}<\/span>\r\n}<\/span><\/code><\/pre>\n
It takes in the following argument<\/p>\n
    \n
  1. \u00a0s<\/strong> – String to be scanned through to populate the Map – SafeMap <\/strong>and when the processing is done it notifies the WaitGroup by invoking Done() method.<\/li>\n
  2. \u00a0sm<\/strong> – SafeMap<\/strong> that has a method Increment() to increment the respective rune value.<\/li>\n
  3. \u00a0wg<\/strong> – WaitGroup<\/strong> to be notified of task completion.<\/li>\n<\/ol>\n
    GoRoutine creator – ConcurrentFrequency<\/h2>\n
    func<\/span> ConcurrentFrequency<\/span>(<\/span>elements [<\/span>]<\/span>string<\/span>)<\/span> FreqMap {<\/span>\r\n\tvar<\/span> sm SafeMap\r\n\r\n\tvar<\/span> wg sync.<\/span>WaitGroup\r\n\r\n\tsm.<\/span>val =<\/span> FreqMap{<\/span>}<\/span>\r\n\r\n\twg.<\/span>Add<\/span>(<\/span>len<\/span>(<\/span>elements)<\/span>)<\/span>\r\n\tfor<\/span> _<\/span>,<\/span> r :=<\/span> range<\/span> elements {<\/span>\r\n\t\tgo<\/span> ParallelFreq<\/span>(<\/span>r,<\/span> &<\/span>sm,<\/span> &<\/span>wg)<\/span>\r\n\t}<\/span>\r\n\twg.<\/span>Wait<\/span>(<\/span>)<\/span>\r\n\r\n\treturn<\/span> sm.<\/span>val\r\n}<\/span><\/code><\/pre>\n
      \n
    1. It receives an input a slice of strings<\/li>\n
    2. Defines a WaitGroup for the len of the slice.<\/li>\n
    3. Creates go routines by invoking go ParallelFreq.<\/em><\/li>\n
    4. Waits for all the goroutines to finish<\/li>\n
    5. Returns the FreqMap.<\/li>\n<\/ol>\n
      Benchmark : go test -v –bench . –benchmem<\/h2>\n
      pkg: letter\r\nBenchmarkSequentialFrequency-16 55041 21012 ns\/op 2995 B\/op 13 allocs\/op\r\nBenchmarkConcurrentFrequency-16 25628 48832 ns\/op 2136 B\/op 14 allocs\/op\r\nPASS\r\nok letter 3.127s<\/pre>\n
      You can further optimise the declaration and initialization of the SafeMap<\/p>\n
      \n
      var sm = SafeMap{FreqMap{}, sync.Mutex{}}<\/pre>\n<\/div>\n
      * You can find more samples in my GitRepo.<\/p>\n
      — THE – END —<\/p>\n
       <\/p>\n","protected":false},"excerpt":{"rendered":"
      Concurrency and Parallelism – (Helpful link) Last few weeks have been interesting, a new year just embarked, my learning pace slowed down; comparatively due to the festivities and obligations around, but I am still trying to maintain. This week\u00a0 tried another exercise from exercism.io. If you have not seen this site, I recommend it highly. […]<\/p>\n","protected":false},"author":1,"featured_media":214,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_exactmetrics_skip_tracking":false,"_exactmetrics_sitenote_active":false,"_exactmetrics_sitenote_note":"","_exactmetrics_sitenote_category":0,"footnotes":""},"categories":[1],"tags":[23,26,24,25],"class_list":["post-213","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-others","tag-golang","tag-mutex","tag-sync","tag-waitgroup"],"_links":{"self":[{"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/posts\/213","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/comments?post=213"}],"version-history":[{"count":0,"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/posts\/213\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/media\/214"}],"wp:attachment":[{"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/media?parent=213"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/categories?post=213"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.samarthya.me\/wps\/wp-json\/wp\/v2\/tags?post=213"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}