/*

 * Copyright (c) 2020 Red Hat, Inc.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301, USA. 

 *

 * $Id: //eng/vdo-releases/aluminum/src/c++/vdo/base/threadConfig.c#2 $

 */

#include "threadConfig.h"

#include "logger.h"

#include "memoryAlloc.h"

#include "constants.h"

#include "types.h"

/**********************************************************************/

static int allocateThreadConfig(ZoneCount      logicalZoneCount,

                                ZoneCount      physicalZoneCount,

                                ZoneCount      hashZoneCount,

                                ZoneCount      baseThreadCount,

                                ThreadConfig **configPtr)

{

  ThreadConfig *config;

  int result = ALLOCATE(1, ThreadConfig, "thread config", &config);

  if (result != VDO_SUCCESS) {

    return result;

  }

  result = ALLOCATE(logicalZoneCount, ThreadID, "logical thread array",

                    &config->logicalThreads);

  if (result != VDO_SUCCESS) {

    freeThreadConfig(&config);

    return result;

  }

  result = ALLOCATE(physicalZoneCount, ThreadID, "physical thread array",

                    &config->physicalThreads);

  if (result != VDO_SUCCESS) {

    freeThreadConfig(&config);

    return result;

  }

  result = ALLOCATE(hashZoneCount, ThreadID, "hash thread array",

                    &config->hashZoneThreads);

  if (result != VDO_SUCCESS) {

    freeThreadConfig(&config);

    return result;

  }

  config->logicalZoneCount  = logicalZoneCount;

  config->physicalZoneCount = physicalZoneCount;

  config->hashZoneCount     = hashZoneCount;

  config->baseThreadCount   = baseThreadCount;

  *configPtr = config;

  return VDO_SUCCESS;

}

/**********************************************************************/

static void assignThreadIDs(ThreadID   threadIDs[],

                            ZoneCount  count,

                            ThreadID  *idPtr)

{

  for (ZoneCount zone = 0; zone < count; zone++) {

    threadIDs[zone] = (*idPtr)++;

  }

}

/**********************************************************************/

int makeThreadConfig(ZoneCount      logicalZoneCount,

                     ZoneCount      physicalZoneCount,

                     ZoneCount      hashZoneCount,

                     ThreadConfig **configPtr)

{

  if ((logicalZoneCount == 0)

      && (physicalZoneCount == 0)

      && (hashZoneCount == 0)) {

    return makeOneThreadConfig(configPtr);

  }

  if (physicalZoneCount > MAX_PHYSICAL_ZONES) {

    return logErrorWithStringError(VDO_BAD_CONFIGURATION,

                                   "Physical zone count %u exceeds maximum "

                                   "(%u)",

                                   physicalZoneCount, MAX_PHYSICAL_ZONES);

  }

  if (logicalZoneCount > MAX_LOGICAL_ZONES) {

    return logErrorWithStringError(VDO_BAD_CONFIGURATION,

                                   "Logical zone count %u exceeds maximum "

                                   "(%u)",

                                   logicalZoneCount, MAX_LOGICAL_ZONES);

  }

  ThreadConfig *config;

  ThreadCount total = logicalZoneCount + physicalZoneCount + hashZoneCount + 2;

  int result = allocateThreadConfig(logicalZoneCount, physicalZoneCount,

                                    hashZoneCount, total, &config);

  if (result != VDO_SUCCESS) {

    return result;

  }

  ThreadID id = 0;

  config->adminThread   = id;

  config->journalThread = id++;

  config->packerThread  = id++;

  assignThreadIDs(config->logicalThreads, logicalZoneCount, &id;;

  assignThreadIDs(config->physicalThreads, physicalZoneCount, &id;;

  assignThreadIDs(config->hashZoneThreads, hashZoneCount, &id;;

  ASSERT_LOG_ONLY(id == total, "correct number of thread IDs assigned");

  *configPtr = config;

  return VDO_SUCCESS;

}

/**********************************************************************/

int makeZeroThreadConfig(ThreadConfig **configPtr)

{

  ThreadConfig *config;

  int result = ALLOCATE(1, ThreadConfig, __func__, &config);

  if (result != VDO_SUCCESS) {

    return result;

  }

  config->logicalZoneCount  = 0;

  config->physicalZoneCount = 0;

  config->hashZoneCount     = 0;

  config->baseThreadCount   = 0;

  *configPtr                = config;

  return VDO_SUCCESS;

}

/**********************************************************************/

int makeOneThreadConfig(ThreadConfig **configPtr)

{

  ThreadConfig *config;

  int result = allocateThreadConfig(1, 1, 1, 1, &config);

  if (result != VDO_SUCCESS) {

    return result;

  }

  config->logicalThreads[0]  = 0;

  config->physicalThreads[0] = 0;

  config->hashZoneThreads[0] = 0;

  *configPtr = config;

  return VDO_SUCCESS;

}

/**********************************************************************/

int copyThreadConfig(const ThreadConfig *oldConfig, ThreadConfig **configPtr)

{

  ThreadConfig *config;

  int result = allocateThreadConfig(oldConfig->logicalZoneCount,

                                    oldConfig->physicalZoneCount,

                                    oldConfig->hashZoneCount,

                                    oldConfig->baseThreadCount,

                                    &config);

  if (result != VDO_SUCCESS) {

    return result;

  }

  config->adminThread   = oldConfig->adminThread;

  config->journalThread = oldConfig->journalThread;

  config->packerThread  = oldConfig->packerThread;

  for (ZoneCount i = 0; i < config->logicalZoneCount; i++) {

    config->logicalThreads[i] = oldConfig->logicalThreads[i];

  }

  for (ZoneCount i = 0; i < config->physicalZoneCount; i++) {

    config->physicalThreads[i] = oldConfig->physicalThreads[i];

  }

  for (ZoneCount i = 0; i < config->hashZoneCount; i++) {

    config->hashZoneThreads[i] = oldConfig->hashZoneThreads[i];

  }

  *configPtr = config;

  return VDO_SUCCESS;

}

/**********************************************************************/

void freeThreadConfig(ThreadConfig **configPtr)

{

  if (*configPtr == NULL) {

    return;

  }

  ThreadConfig *config = *configPtr;

  *configPtr           = NULL;

  FREE(config->logicalThreads);

  FREE(config->physicalThreads);

  FREE(config->hashZoneThreads);

  FREE(config);

}

/**********************************************************************/

static bool getZoneThreadName(const ThreadID  threadIDs[],

                              ZoneCount       count,

                              ThreadID        id,

                              const char     *prefix,

                              char           *buffer,

                              size_t          bufferLength)

{

  if (id >= threadIDs[0]) {

    ThreadID index = id - threadIDs[0];

    if (index < count) {

      snprintf(buffer, bufferLength, "%s%d", prefix, index);

      return true;

    }

  }

  return false;

}

/**********************************************************************/

void getVDOThreadName(const ThreadConfig *threadConfig,

                      ThreadID            threadID,

                      char               *buffer,

                      size_t              bufferLength)

{

  if (threadConfig->baseThreadCount == 1) {

    // Historically this was the "request queue" thread.

    snprintf(buffer, bufferLength, "reqQ");

    return;

  }

  if (threadID == threadConfig->journalThread) {

    snprintf(buffer, bufferLength, "journalQ");

    return;

  } else if (threadID == threadConfig->adminThread) {

    // Theoretically this could be different from the journal thread.

    snprintf(buffer, bufferLength, "adminQ");

    return;

  } else if (threadID == threadConfig->packerThread) {

    snprintf(buffer, bufferLength, "packerQ");

    return;

  }

  if (getZoneThreadName(threadConfig->logicalThreads,

                        threadConfig->logicalZoneCount,

                        threadID, "logQ", buffer, bufferLength)) {

    return;

  }

  if (getZoneThreadName(threadConfig->physicalThreads,

                        threadConfig->physicalZoneCount,

                        threadID, "physQ", buffer, bufferLength)) {

    return;

  }

  if (getZoneThreadName(threadConfig->hashZoneThreads,

                        threadConfig->hashZoneCount,

                        threadID, "hashQ", buffer, bufferLength)) {

    return;

  }

  // Some sort of misconfiguration?

  snprintf(buffer, bufferLength, "reqQ%d", threadID);

}