/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#ifndef DYNAMIC_RESOURCE_MANAGEMENT_RESOURCE_POOL_H
#define DYNAMIC_RESOURCE_MANAGEMENT_RESOURCE_POOL_H

#include "envswitch.h"
#include "rmcommon.h"
#include "utils/balancedbst.h"
#include "utils/linkedlist.h"
#include "utils/simplestring.h"
#include "utils/network_utils.h"

/*
 * The resource pool maintains a set of segments(hosts) which contain allocated
 * resource from resource broker.
 *
 * For each segment, the data structure is designed as below. The instance is
 * maintained as 64-bit aligned for ever. Another segment resource info instance
 * references the corresponding segment instance as the resource tracker.
 *
 *         |<----------- 64 bits (8 bytes) ----------->|
 * 		   +-------------------------------------------+
 *         |        Content of SegStatData             |
 * 		   +-------------------------------------------+
 *         |        Content of SegInfoData      	   |
 *         +-------------------------------------------+
 *                   ^
 *                   |(ref 1:1)
 *                   |
 *         +------------------+
 *         |  SegResInfoData  |
 *         +------------------+
 *
 */

/*
 *------------------------------------------------------------------------------
 * SegInfo
 *------------------------------------------------------------------------------
 */
struct SegInfoData {
	uint32_t		Size;
	uint32_t		AddressAttributeOffset;				   /* 64-bit aligned. */
	uint32_t		AddressContentOffset;
	uint32_t		HostNameOffset;						   /* 64-bit aligned. */
	uint32_t		HostNameLen;
	uint32_t		port;								   /* 64-bit aligned. */
	uint32_t		GRMHostNameOffset;
	uint32_t		GRMHostNameLen;
	uint32_t		GRMRackNameOffset;
	uint32_t		GRMRackNameLen;
	uint32_t		HostAddrCount;
	uint32_t		FailedTmpDirOffset;
	uint32_t		FailedTmpDirLen;
	int32_t			ID;									   /* Global unique ID. */
	uint8_t			master;
	uint8_t			standby;
	uint8_t			alive;
	uint8_t 		Reserved[5];						   /* 64-bit aligned. */
};

typedef struct SegInfoData *SegInfo;
typedef struct SegInfoData  SegInfoData;

/*
 * Extract host name string from SegInfo instance.
 */
#define GET_SEGINFO_HOSTNAME(seginfo) 										   \
		((char *)(seginfo) + ((seginfo)->HostNameOffset))

/*
 * Extract GRM rack name string from SegInfo instance.
 */
#define GET_SEGINFO_GRMRACKNAME(seginfo) 										   \
		((char *)(seginfo) + ((seginfo)->GRMRackNameOffset))

/*
 * Extract GRM host name string from SegInfo instance.
 */
#define GET_SEGINFO_GRMHOSTNAME(seginfo) 										   \
		((char *)(seginfo) + ((seginfo)->GRMHostNameOffset))

/*
 * Extract failed temporary string from SegInfo instance.
 */
#define GET_SEGINFO_FAILEDTMPDIR(seginfo) 										   \
		((char *)(seginfo) + ((seginfo)->FailedTmpDirOffset))

/*
 * Macros for getting segment address content from SegInfo instance.
 */
#define IS_SEGINFO_ADDR_STR(attr)					   	    				   \
		(((attr) & HOST_ADDRESS_CONTENT_STRING) == HOST_ADDRESS_CONTENT_STRING)

#define GET_SEGINFO_ADDR_ATTR_START(seginfo) 								   \
		(char *)((char *)(seginfo) + (seginfo)->AddressAttributeOffset)

#define GET_SEGINFO_ADDR_ATTR_AT(seginfo,index) 							   \
		*((uint16_t *)(GET_SEGINFO_ADDR_ATTR_START(seginfo) + 				   \
					   (index) * sizeof(uint32_t) +			  			   	   \
					   sizeof(uint16_t)))

#define GET_SEGINFO_ADDR_OFFSET_AT(seginfo,index) 				  			   \
		*((uint16_t *)(GET_SEGINFO_ADDR_ATTR_START(seginfo) + 			   	   \
					   (index) * sizeof(uint32_t)))

/* Get host address from SegInfo instance. */
int  getSegInfoHostAddrStr (SegInfo seginfo, int addrindex, AddressString *addr);

int  findSegInfoHostAddrStr(SegInfo seginfo, AddressString addr, int *addrindex);

/*
 * Convert the address in SegInfo instance into string version address regardless
 * the type of address. The result is saved in self maintained buffer.
 */
void  generateSegInfoAddrStr(SegInfo seginfo, int addrindex, SelfMaintainBuffer buff);

/* Generate SegInfo instance's report as a string saved in self maintained buffer. */
void  generateSegInfoReport(SegInfo seginfo, SelfMaintainBuffer buff);


/*
 *------------------------------------------------------------------------------
 * SegStat
 *------------------------------------------------------------------------------
 */

struct SegStatData {
	uint16_t		FailedTmpDirNum;	/* Failed temporary directory number */
	uint8_t			FTSAvailable;		/* If it is available now.			  */
	uint8_t			GRMHandled;			/* If its GRM status is handled */
	uint32_t		FTSTotalMemoryMB;		/* FTS reports memory capacity.   */
	uint32_t		FTSTotalCore;			/* FTS reports core capacity.	  */
	uint32_t		GRMTotalMemoryMB;		/* GRM reports memory capacity.	  */
	uint32_t		GRMTotalCore;			/* GRM reports core capacity. 	  */
	uint32_t		StatusDesc;				/* Description of status */
	uint64_t		RMStartTimestamp;		/* RM process reset timestamp */
	SegInfoData		Info;					/* 64-bit aligned.				  */
};

typedef struct SegStatData *SegStat;
typedef struct SegStatData  SegStatData;

#define SEGSTAT_ID_INVALID -1

/* Values for SegStatData::HAWQAvailable and SegStatData::GLOBAvailable		  */
enum SegAvailabilityStatus {
	RESOURCE_SEG_STATUS_UNSET = 0,
	RESOURCE_SEG_STATUS_AVAILABLE,
	RESOURCE_SEG_STATUS_UNAVAILABLE
};

int setSegStatHAWQAvailability( SegStat machine, uint8_t newstatus);

#define IS_SEGSTAT_FTSAVAILABLE(seg) \
		((seg)->FTSAvailable == RESOURCE_SEG_STATUS_AVAILABLE)

/* Generate SegStat instance's report as a string saved in self maintained buffer. */
void  generateSegStatReport(SegStat segstat, SelfMaintainBuffer buff);

/*
 *------------------------------------------------------------------------------
 * The following node resource maintenance structure is designed as
 *
 * +------------------+
 * | SegResourceData  |
 * +------------------+
 *       |  memcoreratio1
 *       |    (array)        +-----------------+
 *       +-----------------> | GRMContainerSet |--> a list of GRMContainer
 *       |                   +-----------------+
 *       |  memcoreratio2
 *       |    (array)        +-----------------+
 *       +-----------------> | GRMContainerSet |--> a list of GRMContainer
 *                           +-----------------+
 *
 * The nodes are indexed by balanced BST indices to maintain SegResource
 * instances always in sorted status by available resource, allocated resource
 * and io bytes workload.
 *------------------------------------------------------------------------------
 */

struct SegResource;
typedef struct SegResourceData *SegResource;
typedef struct SegResourceData  SegResourceData;

/*
 *------------------------------------------------------------------------------
 * GRMContainer (global resource manager container, YARN for example. )
 * GRMContainerSet
 *------------------------------------------------------------------------------
 */

struct GRMContainerData {
	int64_t		 	 ID;
	int32_t		 	 MemoryMB;
	int32_t		 	 Core;
	int32_t			 Life;			/* Ref container life-cycle management.   */
	bool			 CalcDecPending;/* If this container is calculated into
									   decrease pending resource quota.       */
	char	   		*HostName;		/* Reference the host containing this one.*/
	SegResource		 Resource;		/* The corresponding segment resource.    */
};

typedef struct GRMContainerData  *GRMContainer;
typedef struct GRMContainerData   GRMContainerData;

struct GRMContainerSetData {
	ResourceBundleData  Allocated;
	ResourceBundleData  Available;
	List  	   		   *Containers;
};

typedef struct GRMContainerSetData *GRMContainerSet;
typedef struct GRMContainerSetData  GRMContainerSetData;

GRMContainer createGRMContainer(int64_t      id,
                                int32_t      memory,
								double	 	 core,
								char      	*hostname,
								SegResource  segres);

void freeGRMContainer(GRMContainer ctn);

GRMContainerSet createGRMContainerSet(void);
void freeGRMContainerSet(GRMContainerSet ctns);

GRMContainer popGRMContainerSetContainerList(GRMContainerSet ctns);
GRMContainer getGRMContainerSetContainerFirst(GRMContainerSet ctns);
void appendGRMContainerSetContainer(GRMContainerSet ctns, GRMContainer ctn);
void moveGRMContainerSetContainerList(GRMContainerSet tctns, GRMContainerSet sctns);

/* Get GRMContainerSet of one SegResource instance. */
int getGRMContainerSet(SegResource segres, uint32_t ratio, GRMContainerSet *ctns);
/* Get GRMContainerSet set for specified ratio in one SegResource instance. */
int createAndGetGRMContainerSet(SegResource segres, uint32_t ratio, GRMContainerSet *ctns);

/*
 *------------------------------------------------------------------------------
 * SegResource
 *------------------------------------------------------------------------------
 */
struct SegResourceData {
	SegStat 		Stat;	 		 /* The machine physical information.	  */

	/* Machine level total resource statistics. */
	ResourceBundleData Allocated;
	ResourceBundleData Available;

	int64_t			IOBytesWorkload; /* Accumulated io bytes number.      	  */
	int				SliceWorkload;	 /* Accumulated slice number.             */
	int				NVSeg;			 /* Accumulated vseg number.			  */

	uint64_t        LastUpdateTime;  /* Update it when master receives IMAlive
										message from segment,                 */

	bool			RUAlivePending;  /* A Flag indicates if this segment is
										waiting for RUAlive response          */

	/* Resource maintained by memory/core ratio. */
	GRMContainerSet ContainerSets[RESOURCE_QUEUE_RATIO_SIZE];

	/* Total GRM container size. */
	int				GRMContainerCount;
	int				GRMContainerFailAllocCount;

	/*
	 * When resource manager has resource allocated from resource broker, the
	 * resource increasing quota
	 */
	ResourceBundleData IncPending;
	ResourceBundleData DecPending;

	/*
	 * When resource manager decides to reset resource, the resource level is
	 * marked.
	 */
	ResourceBundleData OldInuse;
};


#define GET_SEGRESOURCE_HOSTNAME(segres) 									   \
		GET_SEGINFO_HOSTNAME(&(segres->Stat->Info))

#define IS_SEGRESOURCE_USABLE(segresource)   								   \
		((!(segresource)->RUAlivePending) && 								   \
		 IS_SEGSTAT_FTSAVAILABLE((segresource)->Stat))

/* Create new SegResource instance that refers SegStat instance. */
SegResource createSegResource(SegStat segstat);

int setSegResHAWQAvailability( SegResource segres, uint8_t newstatus);

/* Set the segment is under or not under RUAlive pending status. */
bool setSegResRUAlivePending( SegResource segres, bool pending);

uint32_t getSegResourceCapacityMemory(SegResource segres);
uint32_t getSegResourceCapacityCore(SegResource segres);

int getSegmentGRMContainerSize(SegResource segres);

enum ResourcePoolQuotaControlFlags
{
	QUOTA_PHASE_TOACC_TO_ACCED = 0,
	QUOTA_PHASE_ACCED_TO_RESPOOL,
	QUOTA_PHASE_TOKICK_TO_KICKED,
	QUOTA_PHASE_KICKED_TO_RETURN,
	QUOTA_PHASE_COUNT
};

/*
 *------------------------------------------------------------------------------
 * RESOURCE POOL
 *
 * Global resource manager instance holds one instance of segment resource pool.
 * All allocated containers from global resource managers are organized here.
 * And all cluster information is maintained here as well, which means segment
 * expansion and shrinking occurs here according to the input from FTS.
 *------------------------------------------------------------------------------
 */

/*
 * function pointer array for allocating resource in resource pool.
 */
typedef int (* ALLOC_RES_FROM_RESPOOL_FUNC) (int32_t 	nodecount,
											 int32_t	minnodecount,
											 uint32_t 	memory,
											 double 	core,
											 int64_t	iobytes,
											 int32_t    slicesize,
											 int32_t	vseglimitpseg,
											 int 		preferredcount,
											 char 	  **preferredhostname,
											 int64_t   *preferredscansize,
											 bool		fixnodecount,
											 List 	  **vsegcounters,
											 int32_t   *totalvsegcount,
											 int64_t   *vsegiobytes);

struct ResourcePoolData {

	/*
	 * When HAWQ RM starts, HAWQ segments' heart-beats are received, and new
	 * segments are registered in resource pool.
	 *
	 * For each segment, there are two statuses,  HAWQ availability and GLOB
	 * availability. HAWQ Availability means it has HAWQ process running and can
	 * be invoked for query processing; GLOB Availability means it is available
	 * from a global resource manager's view (YARN for example).
	 */

	uint32_t		SegmentIDCounter;			/* Internal segment id.       */
	HASHTABLEData	Segments;					/* (uint32_t,ResourceInfo)    */
	HASHTABLEData	SegmentHostNameIndexed;		/* (string,uint32_t) 	      */
	HASHTABLEData	SegmentHostAddrIndexed; 	/* (string,uint32_t) 	      */
	uint32_t		AvailNodeCount;				/* Total count of available nodes. */

	/*
	 * Hold all used hostname strings by GRM containers. This is to save memory
	 * for duplicate hostname strings and simplify memory management when operating
	 * GRM containers.
	 */
	HASHTABLEData	BufferedHostNames;

	/*
	 * The cluster resource capacity counters that are used to efficiently get
	 * resource queue capacity. FTS capacity is defined in hawq-site.xml, GRM
	 * capacity is from global resource manager's node/cluster report.
	 */
	ResourceBundleData FTSTotal;
	ResourceBundleData GRMTotal;
	ResourceBundleData GRMTotalHavingNoHAWQNode;

    uint64_t LastUpdateTime; /* Last time the GRM cluster report is gotten.   */
    uint64_t LastRequestTime;/* Last time the GRM cluster report is sent.     */
    uint64_t LastCheckTime;	 /* Last time the segments' status are checked.   */
    uint64_t LastResAcqTime; /* Last time HAWQ RM acquiring resource .		  */

    uint64_t LastCheckContainerTime;   /* Last time the GRM container report is gotten. */
    uint64_t LastRequestContainerTime; /* Last time the GRM container report is sent.   */

	/*
	 * GRM containers are maintained by memory/core ratio.
	 *
	 * For each memory/core ratio, there is an index implemented as one balanced
	 * binary search tree to help dynamically maintain one fast index to count
	 * nodes having resources  more than expectation. */
    BBST 			OrderedSegResAvailByRatio[RESOURCE_QUEUE_RATIO_SIZE];

	/*
	 * This index is for getting segments having most resource, when resource pool
	 * should timeout some resource back to the global resource manager, this is
	 * used, the purpose is to ensure HAWQ RM has even resource allocated among
	 * segments.
	 */
    BBST 			OrderedSegResAllocByRatio[RESOURCE_QUEUE_RATIO_SIZE];

	/*
	 * The index to help finding the nodes having fewest io bytes number accumulated.
	 */
	BBSTData		OrderedCombinedWorkload;

	/*
	 * This is for caching all resolved hdfs hostnames which are mapped to one
	 * registered segment in resource pool containing HAWQ FTS fixed hostname and
	 * ip addresses.
	 */
	HASHTABLEData	HDFSHostNameIndexed;

	/*
	 * This is for caching all resolved global resource manager hostnames which
	 * are mapped to one registered segment in resource pool containing HAWQ FTS
	 * fixed host name and ip addresses.
	 */
	HASHTABLEData	GRMHostNameIndexed;

	/* The fixed cluster level memory to core ratio. */
	uint32_t		ClusterMemoryCoreRatio;

	/*
	 * GRM Container life-cycle management.
	 *
	 *                     Resource broker allocate containers.
	 *                            |
	 *                            v
	 *                     +------------------------+
	 * Failed notify +---->|   ToAcceptContainers   |
	 * but retry life|     +------------------------+
	 * is not long   |       |    | Notified corresponding
	 * 				 |       |    | segments new resource
	 *               +-------+    | is added without error.
	 * Failed notify |            v
	 * retry life is |     +------------------------+
	 * too long      |     |   AcceptedContainers   |
	 *               |     +------------------------+
	 *               |            | Add to segments maintained
	 *               |            | by resource pool manager.
	 *               |            | The resource is ready.
	 *               |            v
	 *               |     +------------------------+
	 *               |     | Resource pool segments |
	 *               | +---+------------------------+
	 *               | | Containers | Timeout containers
	 *               | | from down  | to be kicked back
	 *               | | segments   | to resource broker
	 *               | |            |
	 *               | |            |
	 *               | |            |              +---------+ Failed notifying
	 *               | |            v              |         | but retry life is
	 *               | |   +------------------------+        | not long
	 *               | |   |    ToKickContainers    |<-------+----+
	 *               | |   +------------------------+             |
	 *               | |          | Notified corresponding        |
	 *               | \          | segments existing resource    |
	 *               |  \         | is to be recycled.            |
	 *               |   v        v        |                      |
	 *               |     +------------------------+             |
	 *               +---->|     KickedContainers   |<------------+
	 *                     +------------------------+ Fail notifying but retry
	 *                            |                   life is too long. Kick it.
	 *                            |
	 *                            v
	 *                      Resource broker returns all the containers now.
	 *
	 */
	HASHTABLEData	ToAcceptContainers;
	HASHTABLEData	ToKickContainers;
	List		   *AcceptedContainers;
	List		   *KickedContainers;
	int				AddPendingContainerCount;
	int				RetPendingContainerCount;

	/*
	 * The flags for testing the life cycle of GRM containers by pausing specified
	 * phases.
	 */
	bool			pausePhase[QUOTA_PHASE_COUNT];

	/*
	 * The function array for extending multiple policies of allocating virtual
	 * segments from the segment pool.
	 */
	ALLOC_RES_FROM_RESPOOL_FUNC allocateResFuncs[RESOURCEPOOL_MAX_ALLOC_POLICY_SIZE];

	/* Slaves file content. */
	int64_t			SlavesFileTimestamp;
	int				SlavesHostCount;

	int				RBClusterReportCounter;
};

typedef struct ResourcePoolData *ResourcePool;
typedef struct ResourcePoolData  ResourcePoolData;

/*
 *------------------------------------------------------------------------------
 * Resource pool operating APIs
 *------------------------------------------------------------------------------
 */

/* Initialize Resource Pool Manager. */
void initializeResourcePoolManager(void);

/*
 * Add new host into the cluster. New segment will be registered, existing
 * segment maybe updated based on latest information passed in.
 */
int addHAWQSegWithSegStat(SegStat segstat, bool *capstatchanged);

/* Update existing host's grm capacity information. */
int updateHAWQSegWithGRMSegStat( SegStat segstat);

/* Find buffered resource host name string. */
void getBufferedHostName(char *hostname, char **buffhostname);

/* Find HAWQ node based on host address or host name. */
int getSegIDByHostName(const char *hostname, int hostnamelen, int32_t *id);
int getSegIDByHostAddr(uint8_t *hostaddr, int32_t hostaddrlen, int32_t *id);
int getSegIDByHDFSHostName(const char *hostname, int hostnamelen, int32_t *id);
int getSegIDByGRMHostName(const char *hostname, int hostnamelen, int32_t *id);
SegResource getSegResource(int32_t id);

/* Add resource container into the resource pool. */
int  addGRMContainerToToBeAccepted(GRMContainer ctn);
void GRMContainerToAccepted(GRMContainer ctn);
void addGRMContainerToResPool(GRMContainer ctn);

void addGRMContainerToToBeKicked(GRMContainer ctn);
void addGRMContainerToKicked(GRMContainer ctn);

void moveAllAcceptedGRMContainersToResPool(void);

void moveGRMContainerSetToAccepted(GRMContainerSet ctns);
void moveGRMContainerSetToKicked(GRMContainerSet ctns);

void dropAllResPoolGRMContainersToToBeKicked(void);
void dropAllToAcceptGRMContainersToKicked(void);

struct VSegmentCounterInternalData {
	uint32_t	HDFSNameIndex;		/* The HDFS host name index. 			  */
	uint32_t	VSegmentCount;		/* Count of segments totally allocated.   */
	uint32_t	SegId;				/* The id for tracking seg resource. 	  */
 	SegResource Resource;			/* Reference the selected segment.   	  */
};

typedef struct VSegmentCounterInternalData  VSegmentCounterInternalData;
typedef struct VSegmentCounterInternalData *VSegmentCounterInternal;

int allocateResourceFromResourcePoolIOBytes2(int32_t 	 nodecount,
										     int32_t	 minnodecount,
										     uint32_t 	 memory,
										     double 	 core,
										     int64_t	 iobytes,
										     int32_t   	 slicesize,
											 int32_t	 vseglimitpseg,
										     int 		 preferredcount,
										     char 	   **preferredhostname,
										     int64_t    *preferredscansize,
										     bool		 fixnodecount,
										     List 	   **vsegcounters,
										     int32_t    *totalvsegcount,
										     int64_t    *vsegiobytes);

int allocateResourceFromResourcePool(int32_t 	nodecount,
									 int32_t	minnodecount,
		 	 	 	 	 	 	 	 uint32_t 	memory,
									 double 	core,
									 int64_t	iobytes,
									 int32_t    slicesize,
									 int32_t	vseglimitpseg,
									 int 		preferredcount,
									 char 	  **preferredhostname,
									 int64_t   *preferredscansize,
									 bool		fixnodecount,
									 List 	  **vsegcounters,
									 int32_t   *totalvsegcount,
									 int64_t   *vsegiobytes);

/* Return query resource to resource pool. */
int returnResourceToResourcePool(int 		memory,
								 double 	core,
								 int64_t 	vsegiobytes,
								 int32_t 	slicesize,
								 List 	  **hosts,
								 bool 		isold);

void returnAllGRMResourceFromSegment(SegResource segres);
void dropAllGRMContainersFromSegment(SegResource segres);

void returnAllGRMResourceFromUnavailableSegments(void);

/* Notify RM SEG to update resource capacity. */
int notifyToBeAcceptedGRMContainersToRMSEG(void);
int notifyToBeKickedGRMContainersToRMSEG(void);

/* Time idle resource from nodes. */
void timeoutIdleGRMResourceToRB(void);
/* Return expected number of containers to GRM */
void forceReturnGRMResourceToRB(void);

/* Check if some hosts are not updated from GRM cluster report. */
bool requireInstantClusterReport(void);
bool allSegmentHasNoGRMContainersAllocated(void);

int addOrderedResourceAllocTreeIndexByRatio(uint32_t ratio, BBST *tree);
int addOrderedResourceAvailTreeIndexByRatio(uint32_t ratio, BBST *tree);
int getOrderedResourceAvailTreeIndexByRatio(uint32_t ratio, BBST *tree);
int getOrderedResourceAllocTreeIndexByRatio(uint32_t ratio, BBST *tree);

void setAllSegResourceGRMUnhandled(void);

void resetAllSegmentsGRMContainerFailAllocCount(void);
void resetAllSegmentsNVSeg(void);

struct RB_GRMContainerStatData
{
	int64_t		ContainerID;
	uint8_t		isActive;
	uint8_t		isFound;
	uint8_t		Reserved[6];
};

typedef struct RB_GRMContainerStatData  RB_GRMContainerStatData;
typedef struct RB_GRMContainerStatData *RB_GRMContainerStat;

void checkGRMContainerStatus(RB_GRMContainerStat ctnstats, int size);

int getClusterGRMContainerSize(void);

void refreshAvailableNodeCount(void);

void checkSlavesFile(void);

void fixClusterMemoryCoreRatio(void);
void adjustSegmentCapacity(SegResource segres);
void adjustSegmentStatFTSCapacity(SegStat segstat);
void adjustSegmentStatGRMCapacity(SegStat segstat);
void adjustSegmentCapacityForNone(SegResource segres);
void adjustSegmentCapacityForGRM(SegResource segres);
void adjustMemoryCoreValue(uint32_t *memorymb, uint32_t *core);

/*
 *------------------------------------------------------------------------------
 * gp_segment_configuration catalog operating APIs.
 *------------------------------------------------------------------------------
 */

/* Clean up gp_segment_configuration */
void cleanup_segment_config(void);

/* Clean up gp_configuration_history */
void cleanup_segment_config_history(void);

#define SEG_STATUS_DESCRIPTION_UP "segment is up"
/* update a segment's status in gp_segment_configuration table */
void update_segment_status(int32_t id, char status, char* description);

/* Add a new entry into gp_segment_configuration table*/
void add_segment_config_row(int32_t 	 id,
							char		*hostname,
							char		*address,
							uint32_t 	 port,
							char 		 role,
							char		 status,
							char*		 description);

/*
 * SegStatData's StatusDesc is a combination of below flags
 */
#define	SEG_STATUS_HEARTBEAT_TIMEOUT			0x00000001
#define	SEG_STATUS_FAILED_PROBING_SEGMENT		0x00000002
#define	SEG_STATUS_COMMUNICATION_ERROR			0x00000004
#define	SEG_STATUS_FAILED_TMPDIR				0x00000008
#define	SEG_STATUS_RM_RESET						0x00000010
#define	SEG_STATUS_NO_GRM_NODE_REPORT			0x00000020

/* Add a new entry into gp_configuration_history table */
void add_segment_history_row(int32_t id,
							 char* hostname,
							 char* description);

/* build a string of status description based on SegStat */
SimpStringPtr build_segment_status_description(SegStat segstat);

/*
 * In resource pool, segment's id starts from 0, however in gp_segment_configuration table,
 * segment registration order starts from 1(0 is for master, -1 is for standby).
 */
#define REGISTRATION_ORDER_OFFSET 1

#define SEGMENT_STATUS_UP   	'u'
#define SEGMENT_STATUS_DOWN 	'd'

#define VALIDATE_RATIO_BIAS 	0.005
#define VALIDATE_RESOURCE_BIAS	0.0001

#define EPSILON 1e-7
#define IS_DOUBLE_ZERO(d)       (fabs(d) < EPSILON)
#define IS_DOUBLE_EQ(x, y)      ((fabs((x) - (y))) <= (EPSILON))
#define IS_DOUBLE_GE(x, y)      (((x) + EPSILON) >= (y))

void validateResourcePoolStatus(bool refquemgr);

/*
 *------------------------------------------------------------------------------
 * Debug supporting functions
 *------------------------------------------------------------------------------
 */
void dumpResourcePoolHosts(const char *filename);
#endif /* DYNAMIC_RESOURCE_MANAGEMENT_RESOURCE_POOL_H */