/**
** @brief
** ROM/SRAM/FlashPage Write Access Timing
*/
static void
s3c4510_bus_write( bus_t *bus, uint32_t adr, uint32_t data )
{
/* see Figure 4-21 in [1] */
part_t *p = PART;
chain_t *chain = CHAIN;
part_set_signal( p, nRCS[0], 1, 0 );
part_set_signal( p, nRCS[1], 1, 1 );
part_set_signal( p, nRCS[2], 1, 1 );
part_set_signal( p, nRCS[3], 1, 1 );
part_set_signal( p, nRCS[4], 1, 1 );
part_set_signal( p, nRCS[5], 1, 1 );
part_set_signal( p, nWBE[0], 1, 1 );
part_set_signal( p, nWBE[1], 1, 1 );
part_set_signal( p, nWBE[2], 1, 1 );
part_set_signal( p, nWBE[3], 1, 1 );
part_set_signal( p, nOE, 1, 1 );
setup_address( bus, adr );
setup_data( bus, data );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, nWBE[0], 1, 0 );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, nWBE[0], 1, 1 );
part_set_signal( p, nRCS[0], 1, 1 );
part_set_signal( p, nRCS[1], 1, 1 );
part_set_signal( p, nRCS[2], 1, 1 );
part_set_signal( p, nRCS[3], 1, 1 );
part_set_signal( p, nRCS[4], 1, 1 );
part_set_signal( p, nRCS[5], 1, 1 );
chain_shift_data_registers( chain, 0 );
}
static Collocations* create_dialog (Collocations *col)
{
GtkWidget *dialog;
GtkWidget *scrolled_win;
GtkWidget *treeview;
GtkListStore *store;
gint result;
dialog = gtk_dialog_new_with_buttons ("Edit Collocations", NULL, GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_widget_set_size_request (GTK_WIDGET (dialog), 600, 500);
treeview = gtk_tree_view_new ();
setup_tree_view (GTK_TREE_VIEW (treeview));
store = gtk_list_store_new (COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
if (col != NULL)
setup_data (col, store);
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), FALSE);
g_object_unref (store);
GtkWidget* add_button = gtk_button_new_from_stock (GTK_STOCK_ADD);
GtkWidget* remove_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
g_signal_connect (G_OBJECT (add_button), "clicked", G_CALLBACK (row_add), (gpointer) treeview);
g_signal_connect (G_OBJECT (remove_button), "clicked", G_CALLBACK (row_remove), (gpointer) treeview);
GtkWidget* hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), add_button, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), remove_button, FALSE, FALSE, 5);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled_win), treeview);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scrolled_win, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 5);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
gtk_widget_show_all (dialog);
result = gtk_dialog_run (GTK_DIALOG (dialog));
if (result == GTK_RESPONSE_OK)
{
Collocations *tmp = NULL;
tmp = get_data (GTK_TREE_VIEW (treeview));
gtk_widget_destroy (dialog);
return tmp;
}
gtk_widget_destroy (dialog);
return col;
}
static void
create_gui (AppData *data)
{
GtkWidget *window;
GtkContainer *sources;
GtkBuilder *builder;
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, "hip.glade", NULL);
gtk_builder_connect_signals (builder, data);
window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
sources = GTK_CONTAINER (gtk_builder_get_object (builder, "sources"));
data->tw_regs = GTK_TREE_VIEW (gtk_builder_get_object (builder, "tw_regs"));
data->tw_mcode = GTK_TREE_VIEW (gtk_builder_get_object (builder, "tw_mcode"));
data->tw_data = GTK_TREE_VIEW (gtk_builder_get_object (builder, "tw_data"));
data->tw_symtable = GTK_TREE_VIEW (gtk_builder_get_object (builder, "tw_symtable"));
g_object_unref (builder);
gtk_container_add (sources, setup_editor (data));
setup_regs (data);
setup_mcode (data);
setup_data (data);
setup_symtable (data);
gtk_widget_show (window);
}
void
sa1110_bus_write( parts *ps, uint32_t adr, uint32_t data )
{
/* see Figure 10-16 in SA doc */
part *p = ps->parts[0];
if ( (adr==0x49000000) && (data==1) ) {
part_set_signal( p, "nCS0", 1, 1 );
part_set_signal( p, "nCS5", 1, 0 );
} else {
part_set_signal( p, "nCS0", 1, 0 );
part_set_signal( p, "nCS5", 1, 1 );
}
part_set_signal( p, "nCS1", 1, 1 );
part_set_signal( p, "nCS2", 1, 1 );
part_set_signal( p, "nCS3", 1, 1 );
part_set_signal( p, "nCS4", 1, 1 );
part_set_signal( p, "RD_nWR", 1, 0 );
part_set_signal( p, "nWE", 1, 1 );
part_set_signal( p, "nOE", 1, 1 );
setup_address( p, adr );
setup_data( p, data );
parts_shift_data_registers( ps );
part_set_signal( p, "nWE", 1, 0 );
parts_shift_data_registers( ps );
part_set_signal( p, "nWE", 1, 1 );
parts_shift_data_registers( ps );
part_set_signal( p, "nCS0", 1, 1 );
part_set_signal( p, "nCS5", 1, 1 );
parts_shift_data_registers( ps );
}
void data_reporter::data_received(dolphiimote_callbacks &callbacks, int wiimote_number, checked_array<const u8> data)
{
if(!init)
setup_data();
u8 hid_type = data[0];
u8 message_type = data[1];
if(message_type > 0x30 && message_type < 0x37)
handle_data_reporting(callbacks, wiimote_number, message_type, data);
}
SystemSetView::SystemSetView(QWidget *parent, SystemSet *s)
:QWidget(parent)
{
this->_sys_set = s;
Init_Gui();
setup_data();
connect(closeButton, SIGNAL(clicked()), this, SLOT(close()));
connect(sure_Button, SIGNAL(clicked()), this, SLOT(button_ok()));
}
static void
setup_database(void)
{
remove_tmp_directory();
g_mkdir_with_parents(tmp_directory, 0700);
database = grn_db_create(context, database_path, NULL);
grn_test_assert_context(context);
setup_ddl();
setup_data();
}
SystemSetView_dock::SystemSetView_dock(QWidget *parent, SystemSet *s)
:QWidget(parent)
{
this->_sys_set = s;
this->sure_Button = new QPushButton(tr("确定"));
sure_Button->setMaximumWidth(80);
set_up_UI();
setup_data();
connect(sure_Button, SIGNAL(clicked()), this, SLOT(button_ok()));
this->setMaximumWidth(300);
}
/**
* bus->driver->(*write)
*
* @brief
* ROM/SRAM/FlashPage Write Access Timing
*/
static void
s3c4510_bus_write( bus_t *bus, uint32_t adr, uint32_t data )
{
/* see Figure 4-21 in [1] */
chain_t *chain = CHAIN;
s3c4510_bus_setup_ctrl( bus, 0x01fffe); /* nOE=1, nRCS0 =0 */
setup_address( bus, adr );
setup_data( bus, data );
chain_shift_data_registers( chain, 0 );
switch (dbus_width)
{
default:
case 8:
s3c4510_bus_setup_ctrl( bus, 0x01fefe); /* nOE=1, nRCS0 =0, nWBE0=0 */
break;
case 16:
s3c4510_bus_setup_ctrl( bus, 0x01fcfe); /* nOE=1, nRCS0 =0, nWBE0-1=0 */
break;
case 32:
s3c4510_bus_setup_ctrl( bus, 0x01f0fe); /* nOE=1, nRCS0 =0, nWBE0-3=0 */
break;
}
setup_address( bus, adr );
setup_data( bus, data );
chain_shift_data_registers( chain, 0 );
s3c4510_bus_setup_ctrl( bus, 0x01ffff); /* nOE=1, nRCS0 =1 */
chain_shift_data_registers( chain, 0 );
DEBUG_LVL2( printf("bus_write %08x @ %08x\n", data, adr); )
}
/**
* bus->driver->(*write)
*
*/
static void
sh7750r_bus_write( bus_t *bus, uint32_t adr, uint32_t data )
{
chain_t *chain = CHAIN;
part_t *p = PART;
int cs[8];
int i;
for (i = 0; i < 8 ; i++)
cs[i] = 1;
cs[(adr & 0x1C000000) >> 26] = 0;
part_set_signal( p, CS[0], 1, cs[0] );
part_set_signal( p, CS[1], 1, cs[1] );
part_set_signal( p, CS[2], 1, cs[2] );
part_set_signal( p, CS[3], 1, cs[3] );
part_set_signal( p, CS[4], 1, cs[4] );
part_set_signal( p, CS[5], 1, cs[5] );
part_set_signal( p, CS[6], 1, cs[6] );
part_set_signal( p, RDWR, 1, 0 );
part_set_signal( p, RDWR2, 1, 0 );
part_set_signal( p, WE[0], 1, 1 );
part_set_signal( p, WE[1], 1, 1 );
part_set_signal( p, WE[2], 1, 1 );
part_set_signal( p, WE[3], 1, 1 );
part_set_signal( p, RD, 1, 1 );
part_set_signal( p, RD2, 1, 1 );
setup_address( bus, adr );
setup_data( bus, data );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, WE[0], 1, 0 );
part_set_signal( p, WE[1], 1, 0 );
part_set_signal( p, WE[2], 1, 0 );
part_set_signal( p, WE[3], 1, 0 );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, WE[0], 1, 1 );
part_set_signal( p, WE[1], 1, 1 );
part_set_signal( p, WE[2], 1, 1 );
part_set_signal( p, WE[3], 1, 1 );
chain_shift_data_registers( chain, 0 );
}
void
cut_setup(void)
{
const gchar *database_path;
remove_tmp_directory();
g_mkdir_with_parents(tmp_directory, 0700);
context = g_new0(grn_ctx, 1);
grn_ctx_init(context, 0);
database_path = cut_build_path(tmp_directory, "database.groonga", NULL);
database = grn_db_create(context, database_path, NULL);
setup_data();
}
int main(int argc, char *argv[])
{
//printf("file has %d bytes.\n",(int)get_file_size("GBT11B_wigglez1hr_01_0123_dump.dat"));
//int nchan,nsamp;
Data *dat=read_gbt("GBT11B_wigglez1hr_01_0123_dump.dat");
printf("nchan and nsamp are %d %d\n",dat->raw_nchan,dat->ndata);
printf("top and bottom channels are %12.5f %12.5f\n",dat->raw_chans[0],dat->raw_chans[dat->raw_nchan-1]);
double t1=omp_get_wtime();
//This sets up the mapping of GBT channels into the linear-in-lambda^2 channels, and cleans up the data
map_chans(dat,12);
clean_rows(dat);
setup_data(dat);
float **tmp=matrix(dat->nchan, dat->ndata);
memset(tmp[0],0,sizeof(tmp[0][0])*dat->ndata*dat->nchan);
dedisperse_gbt(dat,tmp[0]);
printf("total processing took %12.4f seconds.\n",omp_get_wtime()-t1);
FILE *rawfile=fopen("gbt_i.dat","w");
fwrite(dat->raw_data[0],sizeof(dat->raw_data[0][0]),dat->ndata*dat->nchan,rawfile);
fclose(rawfile);
FILE *outfile=fopen("gbt_dedispersed.dat","w");
fwrite(dat->data[0],sizeof(dat->data[0][0]),dat->nchan*dat->ndata,outfile);
fclose(outfile);
FILE *fid=fopen("crap.dat","w");
for (int i=0;i<dat->raw_nchan;i++) {
fwrite(&(dat->raw_chans[i]),1,sizeof(float),fid);
fwrite(&(dat->chans[dat->chan_map[i]]),1,sizeof(float),fid);
}
fclose(fid);
for (int i=dat->ndata-6000;i<dat->ndata-5994;i++) {
printf("dat[1][i]=%12.4f\n",dat->data[1][i]);
}
}
static void
ppc440gx_ebc8_bus_write( bus_t *bus, uint32_t adr, uint32_t data )
{
part_t *p = PART;
chain_t *chain = CHAIN;
part_set_signal( p, nCS, 1, 0 );
part_set_signal( p, nWE, 1, 1 );
part_set_signal( p, nOE, 1, 1 );
setup_address( bus, adr );
setup_data( bus, data );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, nWE, 1, 0 );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, nWE, 1, 1 );
part_set_signal( p, nCS, 1, 1 );
chain_shift_data_registers( chain, 0 );
}
/**
* bus->driver->(*write)
*
*/
static void
bf533_ezkit_bus_write( bus_t *bus, uint32_t adr, uint32_t data )
{
part_t *p = PART;
chain_t *chain = CHAIN;
// printf("Writing %04X to %08X...\n", data, adr);
select_flash( bus );
part_set_signal( p, AOE, 1, 1 );
setup_address( bus, adr );
setup_data( bus, data );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, AWE, 1, 0 );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, AWE, 1, 1 );
unselect_flash( bus );
chain_shift_data_registers( chain, 0 );
}
int main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitWindowPosition(100, 100);
glutInitWindowSize(960, 600);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutCreateWindow("Blasteroids");
glutDisplayFunc(renderScene);
glutReshapeFunc(changeSize);
glutIgnoreKeyRepeat(1);
glutKeyboardFunc(processNormalKeys);
glutSpecialFunc(processSpecialKeys);
glutSpecialUpFunc(processSpecialUpKeys);
srand(time(NULL));
setup_data();
r = random_roid();
CURRENT_TIME = glutGet(GLUT_ELAPSED_TIME);
glutMainLoop();
return 0;
}
int
main (void)
{
OclPlatform *ocl;
Data *data;
ocl = ocl_new (0, CL_DEVICE_TYPE_ALL);
if (ocl == NULL)
return 1;
data = setup_data (ocl, 4096 * 2048);
run_benchmark (setup_single_blocking_queue, "Single blocking queue: %fs\n", data);
run_benchmark (setup_ooo_queue, "Single out-of-order queue: %fs\n", data);
run_benchmark (setup_two_queues, "Two queues: %fs\n", data);
run_benchmark (setup_three_queues, "Three queues: %fs\n", data);
free_data (data);
ocl_free (ocl);
return 0;
}
/**
* bus->driver->(*write)
*
*/
static void
jopcyc_bus_write( bus_t *bus, uint32_t adr, uint32_t data )
{
part_t *p = PART;
chain_t *chain = CHAIN;
bus_area_t area;
component_t *comp;
comp_bus_area( bus, adr, &area, &comp );
if (!comp) {
printf( _("Address out of range\n") );
return;
}
part_set_signal( p, nCS, 1, 0 );
part_set_signal( p, nWE, 1, 1 );
part_set_signal( p, nOE, 1, 1 );
if (comp->ctype == RAM) {
part_set_signal( p, nLB, 1, 0 );
part_set_signal( p, nUB, 1, 0 );
}
setup_address( bus, adr, comp );
setup_data( bus, data, comp );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, nWE, 1, 0 );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, nWE, 1, 1 );
part_set_signal( p, nCS, 1, 1 );
if (comp->ctype == RAM) {
part_set_signal( p, nLB, 1, 1 );
part_set_signal( p, nUB, 1, 1 );
}
chain_shift_data_registers( chain, 0 );
}
/**
* bus->driver->(*write)
*
*/
static void
sharc_21065L_bus_write( bus_t *bus, uint32_t adr, uint32_t data )
{
part_t *p = PART;
chain_t *chain = CHAIN;
if (adr >= 0x080000)
return;
part_set_signal( p, BMS, 1, 0 );
part_set_signal( p, nWE, 1, 1 );
part_set_signal( p, nOE, 1, 1 );
setup_address( bus, adr );
setup_data( bus, adr, data );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, nWE, 1, 0 );
chain_shift_data_registers( chain, 0 );
part_set_signal( p, nWE, 1, 1 );
chain_shift_data_registers( chain, 0 );
}
/*******************************************************************************
* Control the setup process
*******************************************************************************/
void setup ( input_data *input_vars, para_data *para_vars, time_data *time_vars,
geom_data *geom_vars, sn_data *sn_vars, data_data *data_vars,
solvar_data *solvar_vars, control_data *control_vars,
mms_data *mms_vars, FILE *fp_out, int *ierr, char **error )
{
/*******************************************************************************
* Local variables
*******************************************************************************/
int flg, mis, mie, mjs, mje, mks, mke, qis, qie, qjs, qje, qks, qke;
double t1, t2;
/*******************************************************************************
* First put input ny and nz into ny_gl and nz_gl respectively. Use ny
* and nz for local sizes. Determine global indices of local bounds.
* Establish min of nthreads and ng for threaded MPI calls in sweep.
*******************************************************************************/
t1 = wtime();
NY_GL = NY;
NZ_GL = NZ;
NY = NY_GL / NPEY;
NZ = NZ_GL / NPEZ;
JLB = YPROC * NY + 1;
JUB = (YPROC + 1) * NY;
KLB = ZPROC * NZ + 1;
KUB = (ZPROC + 1) * NZ;
NUM_GRTH = MIN( NTHREADS, NG );
/*******************************************************************************
* Allocate needed arrays
*******************************************************************************/
setup_alloc( input_vars, para_vars, sn_vars, data_vars, &flg, ierr, error );
if ( *ierr != 0 )
{
print_error ( fp_out, *error, IPROC, ROOT );
stop_run( flg, 0, 0, para_vars, sn_vars, data_vars, mms_vars,
geom_vars, solvar_vars, control_vars );
}
/*******************************************************************************
* Progress through setups. _delta sets cell and step sizes, _vel sets
* velocity array, _angle sets the ordinates/weights, _mat sets the
* material identifiers, _src sets fixed source, _data sets the
* mock cross section arrays, and expcoeff sets up the scattering
* expansion basis function array.
*******************************************************************************/
setup_delta( input_vars, geom_vars, control_vars );
setup_vel( input_vars, data_vars );
setup_angle( input_vars, sn_vars );
setup_mat( input_vars, geom_vars, data_vars,
&mis, &mie, &mjs, &mje, &mks, &mke );
setup_data( input_vars, data_vars );
expcoeff( input_vars, sn_vars, &NDIMEN );
setup_src( input_vars, para_vars, geom_vars, sn_vars, data_vars, control_vars,
mms_vars, &qis, &qie, &qjs, &qje, &qks, &qke, ierr, error );
if ( *ierr != 0 )
{
print_error ( fp_out, *error, IPROC, ROOT );
stop_run( 2, 0, 0, para_vars, sn_vars, data_vars, mms_vars,
geom_vars, solvar_vars, control_vars );
}
/*******************************************************************************
* Echo the data from this module to the output file. If requested via
* scatp, print the full scattering matrix to file.
*******************************************************************************/
if ( IPROC == ROOT )
{
setup_echo ( fp_out, input_vars, para_vars, geom_vars, data_vars, sn_vars,
control_vars, mis, mie, mjs, mje, mks, mke,
qis, qie, qjs, qje, qks, qke );
if ( SCATP == 1 ) setup_scatp( input_vars, para_vars, data_vars, ierr, error );
}
glmax_i ( ierr, COMM_SNAP );
if ( *ierr != 0 )
{
print_error ( fp_out, *error, IPROC, ROOT );
FREE ( error );
stop_run ( 3, 0, 0, para_vars, sn_vars, data_vars, mms_vars,
geom_vars, solvar_vars, control_vars );
}
t2 = wtime();
TSET = t2 - t1;
}
int main(void)
{
setup_data();
int n = *init_n;
#if 0
unsigned long crc_table[256];
make_crc32_table(crc_table);
#else
#include "crc32table.c"
#endif
printf("mm n=%d\n", n);
int *a = malloc(0x100000);
int *b = malloc(0x100000);
int *c = malloc(0x100000);
assert(a != NULL && b != NULL && c != NULL);
int y,x,i;
/* ----- Initialize ----- */
#if 1
int d = 0;
for (i = 0; i < n*n; i += 4) {
int v0, v1, v2, v3, v4, v5, v6, v7;
v0 = init_data[d ];
v1 = init_data[d+1];
v2 = init_data[d+2];
v3 = init_data[d+3];
v4 = init_data[d+4];
v5 = init_data[d+5];
v6 = init_data[d+6];
v7 = init_data[d+7];
a[i] = v0;
b[i] = v1;
a[i+1] = v2;
b[i+1] = v3;
a[i+2] = v4;
b[i+2] = v5;
a[i+3] = v6;
b[i+3] = v7;
c[i] = 0;
c[i+1] = 0;
c[i+2] = 0;
c[i+3] = 0;
d = (d + 8) % (64*1024);
}
#else
int d = 0;
for(y=0; y<n; y++) {
for(x=0; x<n; x++) {
a[n*y+x] = init_data[d % (64*1024)];
b[n*y+x] = init_data[(d+1) % (64*1024)];
c[n*y+x] = 0;
d +=2;
}
}
#endif
/* ----- main kernel ----- */
#if 1
static int mm[4][4];
for(y = 0; y < n; y += 4) {
for(x = 0; x < n; x += 4) {
int ix, iy;
/* clear temporary sub-matrix */
for (iy = 0; iy < 4; iy++)
for (ix = 0; ix < 4; ix++)
mm[iy][ix] = 0;
/* calc 4x4 sub-matrix */
for (i = 0; i < n; i++) {
#if 1
int v0, v1, v2, v3;
v0 = a[n*(y+0) + i];
v1 = a[n*(y+1) + i];
v2 = a[n*(y+2) + i];
v3 = a[n*(y+3) + i];
mm[0][0] += v0 * b[n*i + x+0];
mm[0][1] += v0 * b[n*i + x+1];
mm[0][2] += v0 * b[n*i + x+2];
mm[0][3] += v0 * b[n*i + x+3];
mm[1][0] += v1 * b[n*i + x+0];
mm[1][1] += v1 * b[n*i + x+1];
mm[1][2] += v1 * b[n*i + x+2];
mm[1][3] += v1 * b[n*i + x+3];
mm[2][0] += v2 * b[n*i + x+0];
mm[2][1] += v2 * b[n*i + x+1];
mm[2][2] += v2 * b[n*i + x+2];
mm[2][3] += v2 * b[n*i + x+3];
mm[3][0] += v3 * b[n*i + x+0];
mm[3][1] += v3 * b[n*i + x+1];
mm[3][2] += v3 * b[n*i + x+2];
mm[3][3] += v3 * b[n*i + x+3];
#else
for (iy = 0; iy < 4; iy++)
for (ix = 0; ix < 4; ix++)
mm[iy][ix] +=
a[n*(y+iy) + i] * b[n*i + x+ix];
#endif
}
/* write temporary sub-matrix to main-matrix */
for (iy = 0; iy < 4; iy++)
for (ix = 0; ix < 4; ix++)
c[n*(y+iy) + (x+ix)] = mm[iy][ix];
}
}
/*
for(y = 0; y < n; y++) {
for(x = 0; x < n; x++) {
int s = 0;
for(i = 0; i < n; i++)
s += a[n*y+i] * b[n*i+x];
c[n*y+x] = s;
}
}
*/
#else
for(y = 0; y < n; y++) {
for(x = 0; x < n; x++) {
for(i = 0; i < n; i++) {
c[n*y+x] += a[n*y+i] * b[n*i+x];
}
}
}
#endif
/* ----- show result ----- */
printf("\n");
#if 1
for(y = n-8; y<n; y++) {
int v0, v1, v2, v3, v4, v5, v6, v7;
int *p = &c[n*y + n-8];
v0 = *(p + 0);
v1 = *(p + 1);
v2 = *(p + 2);
v3 = *(p + 3);
v4 = *(p + 4);
v5 = *(p + 5);
v6 = *(p + 6);
v7 = *(p + 7);
printf("%08x %08x %08x %08x ",
v0, v1, v2, v3);
printf("%08x %08x %08x %08x ",
v4, v5, v6, v7);
printf("\n");
}
#else
for(y = n-8; y<n; y++) {
for(x = n-8; x<n; x++) {
printf("%08x ", c[n*y+x]);
}
printf("\n");
}
#endif
unsigned long sum = 0;
for(y = 0; y < n; y++) {
for(x = 0; x < n; x++) {
//sum += c[n*y+x];
sum = update_crc32(sum, c[n*y+x], crc_table);
}
}
printf("%08lx\n", sum);
return 0;
}
int main(void) {
setup_data();
int n = *init_n;
int iteration = *init_iter;
/* n is multiple of 32, i is multiple of 2 */
printf("stencil n=%d i=%d\n", n, iteration);
int *buf1 = BUF1;
int *buf2 = BUF2;
int x, y, i;
int d = 0;
for(y=0; y<n; y++) {
for(x=0; x<n; x++) {
buf1[x + y*n] = init_data[d % (64*1024)];
buf2[x + y*n] = 0;
d++;
}
}
for(i=0; i<(iteration/2); i++){
for(y=1; y<n-1; y++) {
for(x=1; x<n-1; x++) {
buf2[(x) + (y)*n] =
(buf1[(x ) + (y-1)*n] + buf1[(x-1) + (y )*n] +
buf1[(x+1) + (y )*n] + buf1[(x ) + (y+1)*n] +
buf1[(x-1) + (y-1)*n] + buf1[(x+1) + (y-1)*n] +
buf1[(x-1) + (y+1)*n] + buf1[(x+1) + (y+1)*n] +
buf1[(x ) + (y )*n]) / 9;
}
}
buf2[n+1] = 0x9999999; // hot spot
for(y=1; y<n-1; y++) {
for(x=1; x<n-1; x++) {
buf1[(x) + (y)*n] =
(buf2[(x ) + (y-1)*n] + buf2[(x-1) + (y )*n] +
buf2[(x+1) + (y )*n] + buf2[(x ) + (y+1)*n] +
buf2[(x-1) + (y-1)*n] + buf2[(x+1) + (y-1)*n] +
buf2[(x-1) + (y+1)*n] + buf2[(x+1) + (y+1)*n] +
buf2[(x ) + (y )*n]) / 9;
}
}
buf1[n+1] = 0x9999999; // hot spot
}
printf("\n");
for(y = 0; y < 16; y++) {
for(x = 0; x < 8; x++) {
printf("%08x ", buf1[x + y*n]);
}
printf("\n");
}
int sum = 0;
for(y=0; y<n; y++) {
for(x=0; x<n; x++) {
sum += buf1[x + y*n];
}
}
printf("%08x\n", sum);
return 0;
}
