/*
ok, this is pman init stage two. we will execute this code, and then jump to the process
manager main processing loop.
What we will do here, is setup the page pool. And initialize System services, along with structures.
Notice, we are now task 0 on the system.
*/
void pman_init_stage2()
{
UINT32 linear, physical;
struct pm_thread *pmthr = NULL;
struct pm_task *pmtsk = NULL;
int i = 0;
int init_size = 0;
/* get rid of the init stuff */
destroy_thread(INIT_THREAD_NUM);
destroy_task(INIT_TASK_NUM);
/*
Open used ports
*/
for(i = 0; i <= 12; i++)
{
open_port(i, 3, PRIV_LEVEL_ONLY);
}
/*
Init stage 1 has placed bootinfo at PMAN_MULTIBOOTINFO_PHYS
before initializing the pool we need to know memory size
and that information is there. So lets map it on our page table.
*/
linear = PMAN_MULTIBOOT_LINEAR + SARTORIS_PROCBASE_LINEAR;
physical = PMAN_MULTIBOOT_PHYS;
map_pages(PMAN_TASK, linear, physical, PMAN_MULTIBOOT_PAGES, PGATT_WRITE_ENA, 2);
/* Reallocate init image */
init_size = init_reloc();
pman_print_set_color(0x7);
pman_print("Mapping Malloc %i pages", PMAN_MALLOC_PAGES);
/* Pagein remaining pages for kmalloc */
linear = PMAN_MALLOC_LINEAR + SARTORIS_PROCBASE_LINEAR; // place after multiboot (this will invalidate the map src/dest linear address,
// we cannot use that area anymore, but it's ok, we used it for init copy only.)
physical = PMAN_MALLOC_PHYS;
map_pages(PMAN_TASK, linear, physical, PMAN_MALLOC_PAGES, PGATT_WRITE_ENA, 2);
pman_print("Initializing tasks/threads.");
/* Show MMAP information */
if(((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->flags & MB_INFO_MMAP && ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_length > 0)
{
//Calculate multiboot mmap linear address.
//Sartoris loader left MMAP just after multiboot info structure.
((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_addr = PMAN_MULTIBOOT_LINEAR + sizeof(struct multiboot_info);
pman_print("Multiboot MMAP Size: %i ", ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_length);
pman_print("Multiboot mmap linear address: %x", ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_addr);
struct mmap_entry *entry = NULL;
entry = (struct mmap_entry *)((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_addr;
int kk = 0, mmlen = ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_length / entry->size;
for(kk = 0; kk < mmlen; kk++)
{
pman_print("Multiboot entry size: %i start: %x end: %x type: %i", entry->size, (UINT32)entry->start, (UINT32)entry->end, entry->type);
entry = (struct mmap_entry *)((UINT32)entry + entry->size);
}
}
else
{
pman_print("No MMAP present.");
}
/* Initialize vmm subsystem */
vmm_init((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR, PMAN_INIT_RELOC_PHYS, PMAN_INIT_RELOC_PHYS + init_size);
tsk_init();
thr_init();
/* Mark SCHED_THR as taken! */
pmtsk = tsk_create(PMAN_TASK);
pmtsk->state = TSK_NORMAL;
pmthr = thr_create(SCHED_THR, pmtsk);
pmthr->state = THR_INTHNDL; // ehm... well... it IS an interrupt handler :D
pmthr->task_id = PMAN_TASK;
pmthr->state = THR_INTHNDL;
pman_print("Initializing allocator and interrupts.");
/* Initialize kernel memory allocator */
kmem_init(PMAN_MALLOC_LINEAR, PMAN_MALLOC_PAGES);
/* get our own interrupt handlers, override microkernel defaults */
int_init();
/* Initialize Scheduler subsystem */
sch_init();
pman_print("InitFS2 Service loading...");
/* Load System Services and init Loader */
loader_init((ADDR)PHYSICAL2LINEAR(PMAN_INIT_RELOC_PHYS));
//pman_print_clr(7);
pman_print("Loading finished, return INIT image memory to POOL...");
/* Put now unused Init-Fs pages onto vmm managed address space again. */
vmm_add_mem((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR
,PHYSICAL2LINEAR(PMAN_INIT_RELOC_PHYS)
,PHYSICAL2LINEAR(PMAN_INIT_RELOC_PHYS + init_size));
pman_print("Signals Initialization...");
/* Initialize global signals container */
init_signals();
pman_print("Commands Initialization...");
/* Initialize Commands subsystem. */
cmd_init();
pman_print_set_color(12);
pman_print("PMAN: Initialization step 2 completed.");
/* Create Scheduler int handler */
if(create_int_handler(32, SCHED_THR, FALSE, 0) < 0)
pman_print_and_stop("Could not create Scheduler thread.");
/* This is it, we are finished! */
process_manager();
}
int main(void)
{
// u8 a[] = {0xAA, 0xAA, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,0x99,0xa0,0x04,0x10,0x08,0x01,0x08,0x99};
u8 a[] = {0x11, 0x22, 0x33,0x44, 0x55, 0x66, 0x77};
RobotRate rate;
WheelSpeed wheelspeed;
SystemInit();
USART1_Init(115200);
USART2_Init(115200);
USART3_Init(38400);
UART4_Init(115200);
CAN1_Init();
LED_Init();
// TIM2_Init();
TIM3_Init();
SysTick_Init();
Motor_init();
amp_init();
mag_sensor_init();
flash_init();
DelayMs(1000); //Time for Motor Driver Board to init
//set_all_speedctl();
t3 = micros();
//*************************initial sensor***************************************************************//
while(t < 0x15)
{
if(UART4RecvPtrR != UART4RecvPtrW)
{
op = AHRSCheckDataFrame();
if(op == ACC_METER || op == GYRO || op == ANGLE_OUTPUT || op == MAG_METER )
{
SensorInitial(op);
t++;
}
}
t4 = micros();
time_taken = t4 - t3;
if(time_taken > 3000000)
{
//break;
}
}
sch_init();
sch_add_task(sensors, 6, 20);
sch_add_task(AHRS_compute, 1, 50);
// sch_add_task(led_task, 4, 100);
sch_add_task(UART2Proc, 10, 20);
// sch_add_task(UART3Proc, 3, 20);
// sch_add_task(UART3Proc, 4, 20);
// sch_add_task(FRIDCheck, 2, 20);
sch_start();
while (1)
{
sch_dispatch_tasks();
//Welcome();
}
}
int
main(
int argc, /* arg count */
char * argv[] /* arg vector */
){
static char * context = "main(chain)";
char * stem = NULL; /* dump filename stem */
char * suffix = NULL; /* dump filename suffix */
char * suff2 = NULL; /* last half of suffix */
int nr, nc; /* integer matrix sizes */
int n; /* square matrix/vector size */
real base_x, base_y; /* base of Mandelbrot */
real ext_x, ext_y; /* extent of Mandelbrot */
int limit, seed; /* randmat controls */
real fraction; /* invperc/thresh filling */
int itersLife; /* life iterations */
int itersElastic, relax; /* elastic controls */
int2D i2D; /* integer matrix */
bool2D b2D; /* boolean matrix */
pt1D cities; /* cities point vector */
int n_cities; /* number of cities */
pt1D net; /* net point vector */
int n_net; /* number of net points */
real2D r2D_gauss; /* real matrix for Gaussian */
real2D r2D_sor; /* real matrix for SOR */
real1D r1D_gauss_v; /* real vector input for Gaussian */
real1D r1D_sor_v; /* real vector input for SOR */
real1D r1D_gauss_a; /* real vector answer for Gaussian */
real1D r1D_sor_a; /* real vector answer for SOR */
real1D r1D_gauss_c; /* real vector check for Gaussian */
real1D r1D_sor_c; /* real vector check for SOR */
real tol; /* SOR tolerance */
real realDiff; /* vector difference */
bool choicesSet = FALSE; /* path choices set? */
bool doMandel = TRUE; /* mandel vs. randmat */
bool doInvperc = TRUE; /* invperc vs. thresholding */
bool doDump = FALSE; /* dump intermediate results? */
int argd = 1; /* argument index */
/* arguments */
#if NUMA
MAIN_INITENV(,32000000)
#endif
while (argd < argc){
CHECK(argv[argd][0] == '-',
fail(context, "bad argument", "index", "%d", argd, NULL));
switch(argv[argd][1]){
case 'E' : /* elastic */
itersElastic = arg_int(context, argc, argv, argd+1, argv[argd]);
relax = arg_int(context, argc, argv, argd+2, argv[argd]);
argd += 3;
break;
case 'F' : /* fraction (invperc/thresh) */
fraction = arg_real(context, argc, argv, argd+1, argv[argd]);
argd += 2;
break;
case 'L' : /* life */
itersLife = arg_int(context, argc, argv, argd+1, argv[argd]);
argd += 2;
break;
case 'M' : /* mandel */
base_x = arg_real(context, argc, argv, argd+1, argv[argd]);
base_y = arg_real(context, argc, argv, argd+2, argv[argd]);
ext_x = arg_real(context, argc, argv, argd+3, argv[argd]);
ext_y = arg_real(context, argc, argv, argd+4, argv[argd]);
argd += 5;
break;
case 'N' : /* winnow */
n_cities = arg_int(context, argc, argv, argd+1, argv[argd]);
argd += 2;
break;
case 'R' : /* randmat */
limit = arg_int(context, argc, argv, argd+1, argv[argd]);
seed = arg_int(context, argc, argv, argd+2, argv[argd]);
argd += 3;
break;
case 'S' : /* matrix size */
nr = arg_int(context, argc, argv, argd+1, argv[argd]);
nc = arg_int(context, argc, argv, argd+2, argv[argd]);
argd += 3;
break;
case 'T' : /* SOR tolerance */
tol = arg_real(context, argc, argv, argd+1, argv[argd]);
argd += 2;
break;
case 'c' : /* choice */
CHECK(!choicesSet,
fail(context, "choices already set", NULL));
suffix = arg_str(context, argc, argv, argd+1, argv[argd]);
argd += 2;
switch(suffix[0]){
case 'i' : doInvperc = TRUE; break;
case 't' : doInvperc = FALSE; break;
default :
fail(context, "unknown choice(s)", "choice", "%s", suffix, NULL);
}
switch(suffix[1]){
case 'm' : doMandel = TRUE; break;
case 'r' : doMandel = FALSE; break;
default :
fail(context, "unknown choice(s)", "choice", "%s", suffix, NULL);
}
suff2 = suffix+1;
choicesSet = TRUE;
break;
case 'd' : /* dump */
doDump = TRUE;
argd += 1;
if ((argd < argc) && (argv[argd][0] != '-')){
stem = arg_str(context, argc, argv, argd, argv[argd-1]);
argd += 1;
}
break;
#if GRAPHICS
case 'g' :
gfx_open(app_chain, arg_gfxCtrl(context, argc, argv, argd+1, argv[argd]));
argd += 2;
break;
#endif
#if MIMD
case 'p' :
DataDist = arg_dataDist(context, argc, argv, argd+1, argv[argd]);
ParWidth = arg_int(context, argc, argv, argd+2, argv[argd]);
argd += 3;
break;
#endif
case 'u' :
io_init(FALSE);
argd += 1;
break;
default :
fail(context, "unknown flag", "flag", "%s", argv[argd], NULL);
break;
}
}
CHECK(choicesSet,
fail("context", "choices not set using -c flag", NULL));
/* initialize */
#if MIMD
sch_init(DataDist);
#endif
/* mandel vs. randmat */
if (doMandel){
mandel(i2D, nr, nc, base_x, base_y, ext_x, ext_y);
if (doDump) io_wrInt2D(context, mkfname(stem, NULL, suff2, "i2"), i2D, nr, nc);
} else {
randmat(i2D, nr, nc, limit, seed);
if (doDump) io_wrInt2D(context, mkfname(stem, NULL, suff2, "i2"), i2D, nr, nc);
}
/* half */
half(i2D, nr, nc);
if (doDump) io_wrInt2D(context, mkfname(stem, "h", suff2, "i2"), i2D, nr, nc);
/* invperc vs. thresh */
if (doInvperc){
invperc(i2D, b2D, nr, nc, fraction);
if (doDump) io_wrBool2D(context, mkfname(stem, NULL, suffix, "b2"), b2D, nr, nc);
} else {
thresh(i2D, b2D, nr, nc, fraction);
if (doDump) io_wrBool2D(context, mkfname(stem, NULL, suffix, "b2"), b2D, nr, nc);
}
/* life */
life(b2D, nr, nc, itersLife);
if (doDump) io_wrBool2D(context, mkfname(stem, "l", suffix, "b2"), b2D, nr, nc);
/* winnow */
winnow(i2D, b2D, nr, nc, cities, n_cities);
if (doDump) io_wrPt1D(context, mkfname(stem, "w", suffix, "p1"), cities, n_cities);
/* norm */
norm(cities, n_cities);
if (doDump) io_wrPt1D(context, mkfname(stem, "n", suffix, "p1"), cities, n_cities);
/* elastic */
n_net = (int)(ELASTIC_RATIO * n_cities);
CHECK(n_net <= MAXEXT,
fail(context, "too many net points required",
"number of net points", "%d", n_net, NULL));
elastic(cities, n_cities, net, n_net, itersElastic, relax);
if (doDump) io_wrPt1D(context, mkfname(stem, "e", suffix, "p1"), net, n_net);
/* outer */
n = n_net;
outer(net, r2D_gauss, r1D_gauss_v, n);
if (doDump){
io_wrReal2D(context, mkfname(stem, "o", suffix, "r2"), r2D_gauss, n, n);
io_wrReal1D(context, mkfname(stem, "o", suffix, "r1"), r1D_gauss_v, n);
}
cpReal2D(r2D_gauss, r2D_sor, n, n);
cpReal1D(r1D_gauss_v, r1D_sor_v, n);
/* gauss */
gauss(r2D_gauss, r1D_gauss_v, r1D_gauss_a, n);
if (doDump) io_wrReal1D(context, mkfname(stem, "g", suffix, "r1"), r1D_gauss_a, n);
/* product (gauss) */
product(r2D_gauss, r1D_gauss_a, r1D_gauss_c, n, n);
if (doDump) io_wrReal1D(context, mkfname(stem, "pg", suffix, "r1"), r1D_gauss_c, n);
/* sor */
sor(r2D_sor, r1D_sor_v, r1D_sor_a, n, tol);
if (doDump) io_wrReal1D(context, mkfname(stem, "s", suffix, "r1"), r1D_gauss_a, n);
/* product (sor) */
product(r2D_sor, r1D_sor_a, r1D_sor_c, n, n);
if (doDump) io_wrReal1D(context, mkfname(stem, "ps", suffix, "r1"), r1D_gauss_c, n);
/* difference */
vecdiff(r1D_gauss_a, r1D_sor_a, n, &realDiff);
if (doDump) io_wrReal0D(context, mkfname(stem, "v", suffix, "r0"), realDiff);
#if IEEE
ieee_retrospective(stderr);
#endif
#if NUMA
MAIN_END;
#endif
return 0;
}
int
main(
int argc, /* arg count */
char * argv[] /* arg vector */
){
static char * context = "main(life)";
bool2D world; /* world to evolve */
int nr, nc; /* matrix size */
int iters; /* number of iterations */
char * infn = NULL; /* input file name */
char * outfn = NULL; /* output file name */
int argd = 1; /* argument index */
void * args[5];
/* arguments */
#if NUMA
MAIN_INITENV(,32000000)
BARINIT(GlobalBar);
#endif
while (argd < argc){
CHECK(argv[argd][0] == '-',
fail(context, "bad argument", "index", "%d", argd, NULL));
switch(argv[argd][1]){
case 'L' :
iters = arg_int(context, argc, argv, argd+1, argv[argd]);
argd += 2;
break;
#if GRAPHICS
case 'g' :
gfx_open(app_life, arg_gfxCtrl(context, argc, argv, argd+1, argv[argd]));
argd += 2;
break;
#endif
#if PARALLEL
case 'p' :
DataDist = arg_dataDist(context, argc, argv, argd+1, argv[argd]);
ParWidth = arg_int(context, argc, argv, argd+2, argv[argd]);
argd += 3;
break;
#endif
case 'i' :
infn = arg_str(context, argc, argv, argd+1, argv[argd]);
argd += 2;
break;
case 'o' :
outfn = arg_str(context, argc, argv, argd+1, argv[argd]);
argd += 2;
break;
case 'u' :
io_init(FALSE);
argd += 1;
break;
default :
fail(context, "unknown flag", "flag", "%s", argv[argd], NULL);
break;
}
}
/* setup */
sch_init(DataDist);
CHECK(0 < iters,
fail(context, "non-positive number of iterations",
"number of iterations", "%d", iters, NULL));
io_rdBool2D(context, infn, world, &nr, &nc);
/* run */
TP_any(args, 0, world);
TP_any(args, 1, nr);
TP_any(args, 2, nc);
TP_any(args, 3, iters);
thr_grp(life_thr, args);
/* takedown */
io_wrBool2D(context, outfn, world, nr, nc);
#if GRAPHICS
gfx_close();
#endif
#if IEEE
ieee_retrospective(stderr);
#endif
#if NUMA
BARFREE(GlobalBar);
MAIN_END;
#endif
return 0;
}
MAIN_ENV
#endif
#include "specific.h"
int
main(
int argc, /* arg count */
char * argv[] /* arg vector */
){
static char * context = "main(winnow)";
int2D matrix; /* matrix of values */
bool2D mask; /* mask on values */
int nr, nc, nrM, ncM; /* sizes */
pt1D pt; /* resulting point vector */
int npt; /* number of points to keep */
char * infnMat = NULL; /* input matrix file name */
char * infnMask = NULL; /* input mask file name */
char * outfn = NULL; /* output file name */
int argd = 1; /* argument index */
/* arguments */
#if NUMA
MAIN_INITENV(,32000000)
#endif
while (argd < argc){
CHECK(argv[argd][0] == '-',
fail(context, "bad argument", "index", "%d", argd, NULL));
switch(argv[argd][1]){
case 'N' :
npt = arg_int(context, argc, argv, argd+1, argv[argd]);
argd += 2;
break;
#if GRAPHICS
case 'g' :
gfx_open(app_winnow, arg_gfxCtrl(context, argc, argv, argd+1, argv[argd]));
argd += 2;
break;
#endif
#if MIMD
case 'p' :
DataDist = arg_dataDist(context, argc, argv, argd+1, argv[argd]);
ParWidth = arg_int(context, argc, argv, argd+2, argv[argd]);
argd += 3;
break;
#endif
case 'i' :
infnMat = arg_str(context, argc, argv, argd+1, argv[argd]);
infnMask = arg_str(context, argc, argv, argd+2, argv[argd]);
argd += 3;
break;
case 'o' :
outfn = arg_str(context, argc, argv, argd+1, argv[argd]);
argd += 2;
break;
case 'u' :
io_init(FALSE);
argd += 1;
break;
default :
fail(context, "unknown flag", "flag", "%s", argv[argd], NULL);
break;
}
}
/* setup */
#if MIMD
sch_init(DataDist);
#endif
CHECK(npt > 0,
fail(context, "non-positive number of points requested",
"number of points", "%d", npt, NULL));
io_rdInt2D(context, infnMat, matrix, &nr, &nc);
io_rdBool2D(context, infnMask, mask, &nrM, &ncM);
CHECK((nr == nrM) && (nc == ncM),
fail(context, "matrix/mask size mismatch",
"matrix file", "%s", infnMat,
"mask file", "%s", infnMask, NULL));
/* run */
winnow(matrix, mask, nr, nc, pt, npt);
/* takedown */
io_wrPt1D(context, outfn, pt, npt);
#if GRAPHICS
gfx_close();
#endif
#if IEEE
ieee_retrospective(stderr);
#endif
#if NUMA
MAIN_END;
#endif
return 0;
}
