#pragma once

#include "vmprof.h"

#include "machine.h"

#include "compat.h"

#include <stddef.h>

#include <time.h>

#include <stdlib.h>

#ifdef VMPROF_UNIX

#include <sys/time.h>

#include "vmprof_mt.h"

#include <signal.h>

#include <pthread.h>

#ifdef VMPROF_UNIX

#include "vmprof_getpc.h"

#ifdef VMPROF_LINUX

#include <syscall.h>

#ifdef VMPROF_BSD

#include <sys/syscall.h>

#define MAX_FUNC_NAME 1024

#ifdef VMPROF_UNIX

ssize_t search_thread(pthread_t tid, ssize_t i);

ssize_t insert_thread(pthread_t tid, ssize_t i);

ssize_t remove_thread(pthread_t tid, ssize_t i);

ssize_t remove_threads(void);

#define MAX_STACK_DEPTH \

((SINGLE_BUF_SIZE - sizeof(struct prof_stacktrace_s)) / sizeof(void *))

typedef struct prof_stacktrace_s {

} prof_stacktrace_s;

#define SIZEOF_PROF_STACKTRACE sizeof(long)+sizeof(long)+sizeof(char)

char *vmprof_init(int fd, double interval, int memory,

int proflines, const char *interp_name, int native, int real_time);

int opened_profile(const char *interp_name, int memory, int proflines, int native, int real_time);

#if PY_MAJOR_VERSION >= 3 && !defined(_Py_atomic_load_relaxed)

/* this was abruptly un-defined in 3.5.1 */

void *volatile _PyThreadState_Current;

/* XXX simple volatile access is assumed atomic */

# define _Py_atomic_load_relaxed(pp) (*(pp))

#ifdef RPYTHON_VMPROF

#ifndef RPYTHON_LL2CTYPES

PY_STACK_FRAME_T *get_vmprof_stack(void);

intptr_t vmprof_get_traceback(void *stack, void *ucontext,

void **result_p, intptr_t result_length);

int vmprof_get_signal_type(void);

long vmprof_get_prepare_interval_usec(void);

long vmprof_get_profile_interval_usec(void);

void vmprof_set_prepare_interval_usec(long value);

void vmprof_set_profile_interval_usec(long value);

int vmprof_is_enabled(void);

void vmprof_set_enabled(int value);

int vmprof_get_itimer_type(void);

#ifdef VMPROF_UNIX

int broadcast_signal_for_threads(void);

int is_main_thread(void);