lolly::system Namespace Reference

Classes
class	args
struct	shared_lib_rep

Functions
shared_lib	load_shared_library (string name, url path)
	RESOURCE (shared_lib)
int	call (string cmd)
int	check_output (string s, string &result, bool stderr_only, int64_t timeout)
int	check_stdout (string cmd, string &result)
int	check_stderr (string cmd, string &result)
void	timer_start (string task)
void	timer_cumul (string task)
void	timer_reset (string task)
void	bench_print (tm_ostream &ostream, string task, uint32_t threshold)
static array< string >	collect (hashmap< string, uint32_t > h)
void	bench_print (tm_ostream &ostream)

Variables
static hashmap< string, uint32_t >	timing_level (0)
static hashmap< string, uint32_t >	timing_nr (0)
static hashmap< string, uint32_t >	timing_cumul (0)
static hashmap< string, uint32_t >	timing_last (0)

Function Documentation

load_shared_library()

shared_lib lolly::system::load_shared_library	(	string	name,
		url	path )

Definition at line 28 of file shared_lib.cpp.

                                            {
  return make (shared_lib, name, tm_new<shared_lib_rep> (name, path));
}

RESOURCE()

lolly::system::RESOURCE

(

shared_lib

)

call()

int lolly::system::call

(

string

cmd

)

Definition at line 31 of file subprocess.cpp.

                  {
  tb_process_attr_t attr= {tb_null};
  attr.flags            = TB_PROCESS_FLAG_NO_WINDOW;
  c_string cmd_c (cmd);
 
#if defined(OS_MINGW) || defined(OS_WIN)
  return (int) tb_process_run_cmd (cmd_c, &attr);
#else
  wordexp_t p;
  int       ret= wordexp (cmd_c, &p, 0);
  if (ret != 0) {
    return ret;
  }
  if (p.we_wordc == 0) {
    wordfree (&p);
    return EINVAL;
  }
  ret= (int) tb_process_run (p.we_wordv[0], (tb_char_t const**) p.we_wordv,
                             &attr);
  wordfree (&p);
  return ret;
#endif
}

check_output()

int lolly::system::check_output	(	string	s,
		string &	result,
		bool	stderr_only,
		int64_t	timeout )

Definition at line 57 of file subprocess.cpp.

                                                                           {
  tb_long_t status= -1;
  // init pipe files
  tb_pipe_file_ref_t file[2]= {0};
  if (!tb_pipe_file_init_pair (file, tb_null, 0)) {
    return status;
  }
 
  // init process
  c_string          cmd_ (s);
  tb_process_attr_t attr= {0};
  attr.flags            = TB_PROCESS_FLAG_NO_WINDOW;
  if (stderr_only) {
    attr.err.pipe= file[1];
    attr.errtype = TB_PROCESS_REDIRECT_TYPE_PIPE;
  }
  else {
    attr.out.pipe= file[1];
    attr.outtype = TB_PROCESS_REDIRECT_TYPE_PIPE;
  }
  tb_process_ref_t process= tb_process_init_cmd (cmd_, &attr);
  if (process) {
    // read pipe data
    tb_size_t read= 0;
    // TODO: should be a config here
    tb_byte_t data[8192]= {0};
    tb_size_t size      = sizeof (data);
    tb_bool_t wait      = tb_false;
    while (read < size) {
      tb_long_t real= tb_pipe_file_read (file[0], data + read, size - read);
      if (real > 0) {
        read+= real;
        wait= tb_false;
      }
      else if (!real && !wait) {
        tb_long_t ok   = 0;
        int       retry= 25;
        if (read > 0) {
          retry= 2;
        }
        while (retry > 0 && (ok == 0)) {
          ok   = tb_pipe_file_wait (file[0], TB_PIPE_EVENT_READ, timeout);
          retry= retry - 1;
        }
        tb_check_break (ok > 0);
        wait= tb_true;
      }
      else break;
    }
 
    result= as_string ((tb_char_t*) data);
 
    // wait process
    tb_process_wait (process, &status, timeout);
 
    // exit process
    tb_process_exit (process);
  }
 
  // exit pipe files
  tb_pipe_file_exit (file[0]);
  tb_pipe_file_exit (file[1]);
  return status;
}

check_stdout()

int lolly::system::check_stdout ( string cmd, string & result )

inline

Definition at line 23 of file subprocess.hpp.

                                          {
  return check_output (cmd, result, false, 20);
}

check_stderr()

int lolly::system::check_stderr ( string cmd, string & result )

inline

Definition at line 27 of file subprocess.hpp.

                                          {
  return check_output (cmd, result, true, 20);
}

timer_start()

void lolly::system::timer_start

(

string

task

)

Definition at line 32 of file timer.cpp.

                          {
  // start timer for a given type of task
  if (timing_level[task] == 0) timing_last (task)= (uint32_t) texmacs_time ();
  timing_level (task)++;
}

timer_cumul()

void lolly::system::timer_cumul

(

string

task

)

Definition at line 39 of file timer.cpp.

                          {
  // end timer for a given type of task, but don't reset timer
  timing_level (task)--;
  if (timing_level[task] == 0) {
    uint32_t ms= ((uint32_t) texmacs_time ()) - timing_last (task);
    timing_nr (task)++;
    timing_cumul (task)+= ms;
    timing_last->reset (task);
  }
}

timer_reset()

void lolly::system::timer_reset

(

string

task

)

Definition at line 51 of file timer.cpp.

                          {
  // reset timer for a given type of task
  timing_level->reset (task);
  timing_nr->reset (task);
  timing_cumul->reset (task);
  timing_last->reset (task);
}

bench_print() [1/2]

void lolly::system::bench_print	(	tm_ostream &	ostream,
		string	task,
		uint32_t	threshold )

Definition at line 60 of file timer.cpp.

                                                                   {
  uint32_t elapse_time= timing_cumul[task];
  if (elapse_time < threshold) return;
 
  uint32_t nr= timing_nr[task];
  ostream << "Task '" << task << "' took " << elapse_time << " ms";
  if (nr > 1) ostream << " (" << nr << " invocations)";
  ostream << LF;
}

collect()

static array< string > lolly::system::collect ( hashmap< string, uint32_t > h )

static

Definition at line 71 of file timer.cpp.

                                      {
  array<string>    a;
  iterator<string> it= iterate (h);
  while (it->busy ())
    a << it->next ();
  merge_sort (a);
  return a;
}

bench_print() [2/2]

void lolly::system::bench_print

(

tm_ostream &

ostream

)

Definition at line 81 of file timer.cpp.

                                  {
  // print timings for all types of tasks
  array<string> a= collect (timing_cumul);
  int           i, n= N (a);
  for (i= 0; i < n; i++)
    bench_print (ostream, a[i]);
}

Variable Documentation

timing_level

hashmap< string, uint32_t > lolly::system::timing_level(0) ( 0 )

static

timing_nr

hashmap< string, uint32_t > lolly::system::timing_nr(0) ( 0 )

static

timing_cumul

hashmap< string, uint32_t > lolly::system::timing_cumul(0) ( 0 )

static

timing_last

hashmap< string, uint32_t > lolly::system::timing_last(0) ( 0 )

static