Assignment 1: Part A1 ~ Windows Threads

[iainworkman]

Write a WINDOWS program that creates multiple threads that each perform a specific task until a deadline, without synchronization between the processes/threads of any kind. The number of child threads (threads) and the deadline (deadline) and the maximum integer (size) are to be command-line parameters. Each thread does the same task. The task is given below which utilizes the third command-line parameter (size). The usage is as follows: partA1 threads deadline size. Parent thread task:

• The application should have a parent thread create M child threads.
• The parent should then sleep until the deadline. The simplest way to do this is to use the system call Sleep.
• If the deadline occurs before all children complete, inform the child threads that they should exit. If the deadline has passed, the parent sets a global variable named something like keepRunning to have the value FALSE. The child threads would read this variable each time Square() is called from the main loop of the parent thread. If you find some other way to do this, you may do so. Please document your solution carefully.

Child thread task: Once created, each child then executes a procedure to calculate (but not print out) the squares of each of the first size positive integers in a loop (i.e., 12, 22, 32,42, 52). The restriction is that procedure Square() cannot use any multiplication operations (I want a simple operation that will take a long time to complete and a lot of stack space). Instead, use the following algorithm:

int Square(N)
{
       if (N == 0) return (0);
       return (Square (N-1) + N + N - 1);
}

An example invocation of this program is the following: partA1 4 3 200000. This creates 4 child threads, and has each thread compute Square(1), Square(2), Square(3) ... Square(200000) with a deadline of 3 seconds from the time the parent thread starts running.

You may need to have size be a very large number and deadline to be a fairly small number to get interesting results from this operation.

Upon exit, Each child should print the following: elapsed real time since the child began. number of invocations of the Square() procedure by this thread. You will need to come up with some strategy for counting the number of recursive calls that does not change the parameter list for Square(). Consider an array of counters, indexed by a parameter (threadId) passed to the thread upon creation. The parent and child threads would both have access to this counter. You will need to become familiar with the following Win32 System calls: CreateThread(), GetSystemTime(), and Sleep().

[iainworkman]

Some notes on Windows threads:

#include "common.h"
#include <time.h>
#include <stdio.h>

/* calculates the squares */
int square();
/*  */
int getSystemTime() {
  clock_t clockTime;
  int currTimeInms;
  double milliSeconds;

  clockTime = clock();
  milliseconds = ((double)clockTime / CLOCKS_PER_SEC) * 1000;
  currTimeInMs = (int) milliseconds;
  if(returnTime != NULL) {
    *returnTime = currTimeInMs;
  } else {
    return -1;
  }

  return 0;
}