int main(int argc, char *argv[])
{
int s1 = setStackSize();
if (s1 == 0) //only work if we succeeded in setting stack size
{
printf("Size of struct read_t: %d\n", sizeof(struct read_t));
pthread_t threads[THREADS];
long pids[THREADS];
int i;
struct timeval starttime, endtime;
gettimeofday(&starttime,NULL); //get program start time
//start threads
pthread_mutex_init(&lock, NULL);
for(i=0;i<THREADS;i++)
{
pids[i] = (i+1);
pthread_create(&threads[i],NULL,worker,(void *)pids[i]);
pthread_join(threads[i],NULL);
}
gettimeofday(&endtime,NULL); //get the finish time
long time = (endtime.tv_sec-starttime.tv_sec) * 1000000+(endtime.tv_usec-starttime.tv_usec);
printf("Total run time is %ld microseconds ~= %ld seconds.\n", time, time/10000);
printf("Threads: %d, Working Set Size: %d\n", THREADS, SET);
} else
printf("Couldn't set new stack size, exiting");
//cleanup
pthread_mutex_destroy(&lock);
pthread_exit(NULL);
}
CameraWrapper::CameraWrapper(int frames)
{
// init camera
e = 0;
ctx = rs_create_context(RS_API_VERSION, &e);
check_error();
printf("There are %d connected RealSense devices.\n", rs_get_device_count(ctx, &e));
check_error();
if(rs_get_device_count(ctx, &e) == 0)
{
std::cout << "camera init broken" << std::cout;
}
else
{
dev = rs_get_device(ctx, 0, &e);
check_error();
printf("\nUsing device 0, an %s\n", rs_get_device_name(dev, &e));
check_error();
printf(" Serial number: %s\n", rs_get_device_serial(dev, &e));
check_error();
printf(" Firmware version: %s\n", rs_get_device_firmware_version(dev, &e));
check_error();
// set controls
// NOTE find good laser power, max 15
//rs_enable_stream_preset(dev, RS_STREAM_DEPTH, RS_PRESET_BEST_QUALITY, &e);
rs_enable_stream(dev, RS_STREAM_DEPTH, 640, 480, RS_FORMAT_Z16, 30, &e);
check_error();
rs_set_device_option(dev, RS_OPTION_F200_ACCURACY, 1, &e);
check_error();
rs_set_device_option(dev, RS_OPTION_F200_FILTER_OPTION, 0, &e);
check_error();
rs_enable_stream(dev, RS_STREAM_COLOR, 1920, 1080, RS_FORMAT_RGB8, 30, &e);
// rs_enable_stream_preset(dev, RS_STREAM_COLOR, RS_PRESET_BEST_QUALITY, &e);
check_error();
rs_enable_stream(dev, RS_STREAM_INFRARED, 640,480, RS_FORMAT_Y8, 30, &e);
//rs_enable_stream_preset(dev, RS_STREAM_INFRARED, RS_PRESET_BEST_QUALITY, &e);
check_error();
rs_start_device(dev, &e);
check_error();
// get intrinsics and convert them to opencv mat
// IR and DEPTH are the same for f200, so this is basically overhead
rs_get_stream_intrinsics(dev, RS_STREAM_DEPTH, &depth_intrin, &e);
check_error();
rs_get_device_extrinsics(dev, RS_STREAM_DEPTH, RS_STREAM_COLOR, &depth_to_color, &e);
check_error();
rs_get_stream_intrinsics(dev, RS_STREAM_COLOR, &color_intrin, &e);
check_error();
rs_get_stream_intrinsics(dev, RS_STREAM_INFRARED, &ir_intrin, &e);
check_error();
depthScale = rs_get_device_depth_scale(dev, &e);
check_error();
}
// set number of frames to record
setStackSize(frames);
}
TaskProximity::TaskProximity(SI1143* si1143,rtos::Mutex* mutexI2C,
rtos::Queue<SI1143ProximityMessage,PROXIMITY_QUEUE_LENGHT>* queue,
osPriority priority, uint32_t stackSize, unsigned char *stackPointer):TaskProximity(si1143,mutexI2C,queue) {
setPriority(priority);
setStackSize(stackSize);
setStackPointer(stackPointer);
setState(SLEEPING);
}
void QtThread::start(void *(*start_routine)(void*), void *parameter)
{
setStackSize(STACK_SIZE);
this->start_routine = start_routine;
this->pointer = parameter;
QThread::start();
}
TaskLight::TaskLight(MAX44009* max44009,rtos::Mutex* mutexI2C,
rtos::Queue<MAX44009Message,LIGHT_QUEUE_LENGHT>* queue,
osPriority priority, uint32_t stackSize, unsigned char *stackPointer):TaskLight(max44009,mutexI2C,queue) {
setPriority(priority);
setStackSize(stackSize);
setStackPointer(stackPointer);
setState(SLEEPING);
}
Signal::Manager::Manager()
{
setStackSize((size_t)(4 * getpagesize()));
::sigemptyset(&mask);
if(sigprocmask(SIG_BLOCK, &mask, nullptr) < 0)
{
throw;
}
fd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
Poller::get()->addListener(this);
}
CItemCurrency::CItemCurrency(uint16 id) : CItem(id)
{
setType(ITEM_CURRENCY);
setStackSize(999999999);
}
Thread::Thread(Type type, QObject *parent) :
QThread(parent),
m_type(type)
{
setStackSize(512 * 1024);
}
