dlb.h

Go to the documentation of this file.

/*********************************************************************************/
/*  Copyright 2009-2024 Barcelona Supercomputing Center                          */
/*                                                                               */
/*  This file is part of the DLB library.                                        */
/*                                                                               */
/*  DLB is free software: you can redistribute it and/or modify                  */
/*  it under the terms of the GNU Lesser General Public License as published by  */
/*  the Free Software Foundation, either version 3 of the License, or            */
/*  (at your option) any later version.                                          */
/*                                                                               */
/*  DLB 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 Lesser General Public License for more details.                          */
/*                                                                               */
/*  You should have received a copy of the GNU Lesser General Public License     */
/*  along with DLB.  If not, see <https://www.gnu.org/licenses/>.                */
/*********************************************************************************/
 
#ifndef DLB_H
#define DLB_H
 
#include "dlb_types.h"
#include "dlb_errors.h"
#include <stdbool.h>
#include <stddef.h>
 
/* DLB Version:
 *  major version: DLB_VERSION >> 16 & 0xff
 *  minor version: DLB_VERSION >> 8  & 0xff
 *  patch version: DLB_VERSION       & 0xff
 */
#define DLB_VERSION 0x30601
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/*********************************************************************************/
/*    Status                                                                     */
/*********************************************************************************/
 
int DLB_Init(int ncpus, const_dlb_cpu_set_t mask, const char *dlb_args);
 
int DLB_Finalize(void);
 
int DLB_PreInit(const_dlb_cpu_set_t mask, char ***next_environ);
 
int DLB_Enable(void);
 
int DLB_Disable(void);
 
int DLB_SetMaxParallelism(int max);
 
int DLB_UnsetMaxParallelism(void);
 
 
/*********************************************************************************/
/*    Callbacks                                                                  */
/*********************************************************************************/
 
int DLB_CallbackSet(dlb_callbacks_t which, dlb_callback_t callback, void *arg);
 
int DLB_CallbackGet(dlb_callbacks_t which, dlb_callback_t *callback, void **arg);
 
 
/*********************************************************************************/
/*    Lend                                                                       */
/*********************************************************************************/
 
int DLB_Lend(void);
 
int DLB_LendCpu(int cpuid);
 
int DLB_LendCpus(int ncpus);
 
int DLB_LendCpuMask(const_dlb_cpu_set_t mask);
 
 
/*********************************************************************************/
/*    Reclaim                                                                    */
/*********************************************************************************/
 
int DLB_Reclaim(void);
 
int DLB_ReclaimCpu(int cpuid);
 
int DLB_ReclaimCpus(int ncpus);
 
int DLB_ReclaimCpuMask(const_dlb_cpu_set_t mask);
 
 
/*********************************************************************************/
/*    Acquire                                                                    */
/*********************************************************************************/
 
int DLB_AcquireCpu(int cpuid);
 
int DLB_AcquireCpus(int ncpus);
 
int DLB_AcquireCpuMask(const_dlb_cpu_set_t mask);
 
int DLB_AcquireCpusInMask(int ncpus, const_dlb_cpu_set_t mask);
 
 
/*********************************************************************************/
/*    Borrow                                                                     */
/*********************************************************************************/
 
int DLB_Borrow(void);
 
int DLB_BorrowCpu(int cpuid);
 
int DLB_BorrowCpus(int ncpus);
 
int DLB_BorrowCpuMask(const_dlb_cpu_set_t mask);
 
int DLB_BorrowCpusInMask(int ncpus, const_dlb_cpu_set_t mask);
 
/*********************************************************************************/
/*    Return                                                                     */
/*********************************************************************************/
 
int DLB_Return(void);
 
int DLB_ReturnCpu(int cpuid);
 
int DLB_ReturnCpuMask(const_dlb_cpu_set_t mask);
 
 
/*********************************************************************************/
/*    DROM Responsive                                                            */
/*********************************************************************************/
 
int DLB_PollDROM(int *ncpus, dlb_cpu_set_t mask);
 
int DLB_PollDROM_Update(void);
 
 
/*********************************************************************************/
/*    Misc                                                                       */
/*********************************************************************************/
 
int DLB_CheckCpuAvailability(int cpuid);
 
int DLB_Barrier(void);
 
int DLB_BarrierAttach(void);
 
int DLB_BarrierDetach(void);
 
dlb_barrier_t* DLB_BarrierNamedRegister(const char *barrier_name,
        dlb_barrier_flags_t flags);
 
dlb_barrier_t* DLB_BarrierNamedGet(const char *barrier_name,
        dlb_barrier_flags_t flags);
 
int DLB_BarrierNamed(dlb_barrier_t *barrier);
 
int DLB_BarrierNamedAttach(dlb_barrier_t *barrier);
 
int DLB_BarrierNamedDetach(dlb_barrier_t *barrier);
 
int DLB_SetVariable(const char *variable, const char *value);
 
int DLB_GetVariable(const char *variable, char *value);
 
int DLB_PrintVariables(int print_extended);
 
int DLB_PrintShmem(int num_columns, dlb_printshmem_flags_t print_flags);
 
const char* DLB_Strerror(int errnum);
 
int DLB_SetObserverRole(bool thread_is_observer);
 
int DLB_GetVersion(int *major, int *minor, int *patch);
 
 
int DLB_GetGPUAffinity(char *buffer, size_t buffer_size, bool full_uuid);
 
int DLB_AutoSizerStart(void) __attribute__((deprecated));
int DLB_AutoSizerEnd(void) __attribute__((deprecated));
 
#ifdef __cplusplus
}
#endif
 
#endif /* DLB_H */