Code terminates with message "Killed" before desired number of iterations

Question

My C program is supposed to run 100000 tests to guarantee accuracy but it terminates around 38000 with the message "Killed" without citing any errors, does anyone know what would cause this? The goal of the code is to simulate a card game called "Idiots Delight" with a dollar amount won for each card the player discards and a jackpot if all cards are discarded. The goal is to determine a playing fee to guarantee the house will make a $5 profit for every game played. None of the functions are throwing any errors but it is exiting for an unknown reason. I believe it may be a memory leak but I am not positive.

/////From Header File/////
   double Uniform(double a, double b)
/* =========================================================== 
 * Returns a uniformly distributed real number between a and b. 
 * NOTE: use a < b
 * ===========================================================
 */
{ 
  return (a + (b - a) * Random());
}

////End Of Functions From Header File/////

struct NODES {
    int suit; //Clubs(0), Diamonds(1), Hearts(2), Spades(3)
    int rank; //Ace = 1; Jack = 11; Queen = 12; King = 13
    struct NODES *next;
};
typedef struct NODES NODE;

struct CardDeck {
    int clubs[13];
    int diamonds[13];
    int hearts[13];
    int spades[13];
    struct NODES mDeck;
    struct NODES hand;
    NODE * dHead;
    NODE * hHead;
    NODE * refCard;
    NODE * swapA;
    NODE * swapB;
};



struct CardDeck initDeck (struct CardDeck deck){
    deck.refCard = deck.dHead;
    for(int j = 0; j < 4; j++)
        for (int i = 1; i < 14; i++){
            if (deck.refCard == deck.dHead){
                deck.dHead -> suit = j;
                deck.dHead -> rank = i;
                deck.dHead -> next = (NODE *)malloc(sizeof(NODE));
                deck.refCard = deck.dHead -> next;
            }
            else{
                deck.refCard -> suit = j;
                deck.refCard -> rank = i;
                if ((j == 3) && (i == 13)){
                    deck.refCard -> next = NULL;
                }
                else{
                    deck.refCard -> next = (NODE *)malloc(sizeof(NODE));
                    deck.refCard = deck.refCard -> next;
                }
            }
        }
     return deck;
}

struct CardDeck SwapCards(struct CardDeck deck, int src, int dest){  
    deck.swapA = deck.dHead;
    deck.swapB = deck.dHead;
    int tempSuit;
    int tempRank;
    for (int i = 0; i < src; i++){
        deck.swapA = deck.swapA -> next;
    }
    for (int i = 0; i < dest; i++){
        deck.swapB = deck.swapB -> next;
    }
    tempSuit = deck.swapA -> suit;
    tempRank = deck.swapA -> rank;
    deck.swapA -> suit = deck.swapB -> suit;
    deck.swapA -> rank = deck.swapB -> rank;
    deck.swapB -> suit = tempSuit;
    deck.swapB -> rank = tempRank;

    return deck;
}

struct CardDeck shuffleDeck (struct CardDeck deck){
    int src, dest;
    for (int i = 0; i < NCARDS; i++){
        src = i;
        dest = Uniform(0,1);
        deck = SwapCards(deck,src,dest);
    }
    return deck;
}


struct CardDeck initHand(struct CardDeck deck){
    deck.swapA = deck.dHead;
    deck.swapB = deck.dHead;
    for(int i = 0; i < 3; i++){
        deck.swapA = deck.swapA -> next;
    }   
    deck.dHead = deck.swapA -> next;
    deck.hHead = deck.swapB;
    deck.swapA -> next = NULL;
    NODE * first;
    NODE * second;
    NODE * third;
    NODE * fourth;
    first = deck.swapA;
    fourth = deck.hHead;
    deck.hHead = deck.hHead -> next;
    third = deck.hHead;
    deck.hHead = deck.hHead -> next;
    second = deck.hHead;
    deck.hHead = deck.hHead -> next;
    deck.hHead -> next = second;
    second -> next = third;
    third -> next = fourth;
    fourth -> next = NULL;
    deck.refCard = fourth;
    return deck;
}


struct CardDeck Draw(struct CardDeck deck, int inHand){
    NODE * new = (NODE *)malloc(sizeof(NODE));
    new = deck.dHead;
    deck.dHead = deck.dHead -> next;
    new -> next = deck.hHead;
    deck.hHead = new;
    inHand++;
    if(inHand == 1)
        deck.hHead -> next = NULL;
    return deck;
}

int Play(struct CardDeck deck, int fee){
    int cardsRem = NCARDS;
    int inDeck = NCARDS-4;
    int inHand = 4;
    int prize = 0;
    int discards = 0;
    deck = initHand(deck);
    deck.refCard = deck.hHead -> next -> next -> next;
    while ((inDeck || discards) && cardsRem){
        discards = 0;
        while(inHand < 4 && inDeck){
            deck = Draw(deck, inHand);
            inHand++;
            inDeck--;
        }
        if(inHand>3){
        deck.refCard = deck.hHead -> next -> next -> next;
            if(deck.hHead -> rank == deck.refCard -> rank){
                deck.hHead = deck.refCard -> next;
                inHand = inHand - 4;
                cardsRem = cardsRem - 4;
                discards = 1;
            }
            else if(deck.hHead -> suit == deck.refCard -> suit){
                deck.hHead -> next = deck.refCard;
                inHand = inHand - 2;
                cardsRem = cardsRem - 2;
                discards = 1;
            }
            else if(!discards && inDeck){
                deck = Draw(deck,inHand);
                inHand++;
                inDeck--;
            }
        }

    }
    if (cardsRem != 0)
        prize = NCARDS - cardsRem;
    else
        prize = 10000;;
    int profit = fee - prize;
    return profit;
}


void main(){
    struct CardDeck mainDeck;
    int fee = 0;
    float avgProfit = 0;
    float desiredAvgProfit = 5;
    int bestFee = 0;
    for (int i=1;i<14;i++){
        mainDeck.clubs[i-1] = i;
        mainDeck.diamonds[i-1] = i;
        mainDeck.hearts[i-1] = i;
        mainDeck.spades[i-1] = i;
    }
    mainDeck.dHead = (NODE *)malloc(sizeof(NODE));
    mainDeck.dHead -> suit = -1;
    mainDeck.hHead = (NODE *)malloc(sizeof(NODE));
    for(int i = 0; i < 100000; i++){
        fee = 0;
        while(avgProfit < desiredAvgProfit){
            mainDeck = initDeck(mainDeck);
            mainDeck = shuffleDeck(mainDeck);
            printf("%d\n",i);
            avgProfit = (avgProfit + Play(mainDeck, fee))/2;
            fee++;
            }
        avgProfit = 0;
        bestFee = bestFee + fee;
        }
    printf("Ideal Fee: %d\n", bestFee/100000);
}

Answer 1

Just from a quick inspection of your code, I can see that in initDeck, you malloc 52 cards, but I don't see any calls to free anywhere. I would expect that somewhere in Play, you should be freeing cards as they get "used up". So you were right, there is indeed a memory leak.