• Threads
  • A mechanism that permits a single process to perform multiple tasks concurrently
• Distinct Attributes:
  • Thread ID
  • errno
  • Stack (in the stack space of the process)
• Shared Attributes:
  • Process, group and session IDs
  • Open file descriptors
  • Signal dispositions
  • Text/code segment
  • Initialized data, uninitialized data, and heap segments

• "Global" Data Segments:
  • Threads can "share" variables in the initialized data, uninitialized data, and heap segments
• Stack:
  • Threads shouldn't "share" variables on the stack (but can, in some sense, because each thread's stack is in the stack space of the process)

• Single Threaded Programs:
  • Function/block scope means the same identifier in different functions/blocks refers to different entities
• Multi-Threaded Programs:
  • Distinct stacks means the same identifier in the same function/block in different threads refers to different entities

unixexamples/pthreads/memory0.c

        #include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed


static void
*code_for_thread1(void *arg)
{
  int count;
  
  printf("count in thread 1 is initially %d\n", count);
  count = 20;
  printf("count in thread 1 is finally   %d\n", count);
  return NULL;
}



int
main(void)
{
  int       count;
  pthread_t thread1;
  void      *thread1_result;

  count = 100;
  printf("count in main thread is initially %d\n", count);

  pthread_create(&thread1, NULL, code_for_thread1, NULL);
  pthread_join(thread1, &thread1_result);
  
  printf("count in main thread is finally   %d\n", count);
  exit(0);
}
        

• Single Threaded Programs:
  • File scope means one identifier can be used in different functions to refer to the same entity
• Multi-Threaded Programs:
  • File scope means one identifier can be used in different threads to refer to the same entity

unixexamples/pthreads/memory1.c

        #include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed


int count;


static void
*code_for_thread1(void *arg)
{
  printf("count in thread 1 is initially %d\n", count);
  count = 20;
  printf("count in thread 1 is finally   %d\n", count);
  return NULL;
}



int
main(void)
{
  pthread_t thread1;
  void      *thread1_result;

  count = 10;
  printf("count in main thread is initially %d\n", count);

  pthread_create(&thread1, NULL, code_for_thread1, NULL);
  pthread_join(thread1, &thread1_result);
  
  printf("count in main thread is finally   %d\n", count);
  exit(0);
}
        

• A Question:
  • Can the address of a variable with function scope be stored in a variable with file scope?
  • Yes
• Consequences:
  • What symptoms can arise as a result of using such a pointer?
  • Segmentation faults, garbage, etc...

unixexamples/pthreads/memory4.c

        #include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed


int *ptr;


static void
useless_count(void)
{
  int count = 0;
  ptr = &count;

  count++;
}


static void
*code_for_thread1(void *arg)
{
  printf("count in thread 1 is initially %d\n", *ptr);
  useless_count();
  printf("count in thread 1 is finally   %d\n", *ptr);
  return NULL;
}


int
main(void)
{
  pthread_t thread1;
  void      *thread1_result;

  // What happens if you remove the following statement?
  useless_count();
  printf("count in main thread is initially %d\n", *ptr);

  pthread_create(&thread1, NULL, code_for_thread1, NULL);
  pthread_join(thread1, &thread1_result);
  
  printf("count in main thread is finally   %d\n", *ptr);
  exit(0);
}
        

• An Observation:
  • Variables can be declared/defined in a function and given static duration (even though they have function scope)
• Recall:
  • Such variables are in the unitialized data segment (BSS)
• A Question Revisited:
  • Can the address of a variable with function scope be stored in a variable with file scope?
  • Yes

unixexamples/pthreads/memory3.c

        #include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed


int *ptr;


static void
running_count(void)
{
  static int count = 0;
  ptr = &count;

  count++;
}


static void
*code_for_thread1(void *arg)
{
  printf("count in thread 1 is initially %d\n", *ptr);
  running_count();
  printf("count in thread 1 is finally   %d\n", *ptr);
  return NULL;
}


int
main(void)
{
  pthread_t thread1;
  void      *thread1_result;

  running_count();
  printf("count in main thread is initially %d\n", *ptr);

  pthread_create(&thread1, NULL, code_for_thread1, NULL);
  pthread_join(thread1, &thread1_result);
  
  printf("count in main thread is finally   %d\n", *ptr);
  exit(0);
}
        

• Another Question:
  • What is the duration of a variable with function scope that is declared/defined in main()?
  • It has automatic duration but it is almost as long as a variable with static duration (because main() is the first function called and doesn't exit until termination)
• A Question Revisited:
  • Can the address of a variable with function scope be stored in a variable with file scope?
  • Yes

unixexamples/pthreads/memory2.c

        #include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed


int *ptr;


static void
*code_for_thread1(void *arg)
{
  printf("count in thread 1 is initially %d\n", *ptr);
  *ptr = 20;
  printf("count in thread 1 is finally   %d\n", *ptr);
  return NULL;
}



int
main(void)
{
  int       count;
  pthread_t thread1;
  void      *thread1_result;

  ptr   = &count;
  count = 10;
  printf("count in main thread is initially %d\n", *ptr);

  pthread_create(&thread1, NULL, code_for_thread1, NULL);
  pthread_join(thread1, &thread1_result);
  
  printf("count in main thread is finally   %d\n", *ptr);
  exit(0);
}
        

• Still Another Question:
  • What variables are on the stack when main() calls foo() which itself calls bar()?
  • The variables declared/defined in bar() on top of those declared/defined in foo() on top of those declared/defined in in main()
• A Question Revisited:
  • Can the address of a variable with function scope be stored in a variable with file scope?
  • Yes

unixexamples/pthreads/memory6.c

        #include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed


int *ptr;

static void
some_function(void)
{
  printf("count in some_function() in thread 1 is initially %d\n", *ptr);
  *ptr = 20;
  printf("count in some_function() in thread 1 is finally   %d\n", *ptr);
}


static void
*code_for_thread1(void *arg)
{
  int     count;
  ptr   = &count;
  count = 10;

  printf("count in thread 1 is initially %d\n", *ptr);
  some_function();
  printf("count in thread 1 is finally   %d\n", *ptr);
  return NULL;
}



int
main(void)
{
  pthread_t thread1;
  void      *thread1_result;

  // What happens if the following is included?
  //printf("count in main thread is initially %d\n", *ptr);

  pthread_create(&thread1, NULL, code_for_thread1, NULL);
  pthread_join(thread1, &thread1_result);
  
  // What happens if the following is included?
  //printf("count in main thread is finally   %d\n", *ptr);
  exit(0);
}
        

• Single-Threaded Programs:
  • Using pointers (with file scope) to variables with function scope is inappropriate in single-threaded programs (but you are unlikely to want to do it)
• Multi-Threaded Programs:
  • In multi-threaded programs it's something that you're more likely to want to do but should avoid

• Being "Clever":
  • Declare/define a variable with function scope and static duration in the entry-point for the thread and then assign its address to a pointer with file scope
• The Rationale:
  • They're "owned by" the thread
• The Problems:
  • The order in which the threads are created might matter
• The Right Way(s):
  • Thread-Specific Data
  • Thread-Local Storage

unixexamples/pthreads/memory5.c

        #include <pthread.h>
#include <stdio.h>    // For printf()
#include <stdlib.h>   // For exit()
#include <string.h>   // For strlen()
#include <unistd.h>   // For sleep() if needed


int *ptr1, *ptr2;



static void
*code_for_thread1(void *arg)
{
  static int n_thread1 = 10;
  ptr1 = &n_thread1;

  printf("n_thread1 in thread 1 %d\n", *ptr1);

  // What happens if the following is included?
  //printf("n_thread2 in thread 1 %d\n", *ptr2);
  return NULL;
}


static void
*code_for_thread2(void *arg)
{
  static int n_thread2 = 20;
  ptr2 = &n_thread2;
  

  printf("n_thread1 in thread 2 %d\n", *ptr1);
  printf("n_thread2 in thread 2 %d\n", *ptr2);
  return NULL;
}


int
main(void)
{
  pthread_t thread1, thread2;
  void      *thread1_result, *thread2_result;

  pthread_create(&thread1, NULL, code_for_thread1, NULL);

  pthread_join(thread1, &thread1_result);

  pthread_create(&thread2, NULL, code_for_thread2, NULL);

  pthread_join(thread2, &thread2_result);

  printf("n_thread1 in main thread after join %d\n", *ptr1);
  printf("n_thread2 in main thread after join %d\n", *ptr2);

  exit(0);
}