static void adios_transform_attach_byte_array_dimensions_old(struct adios_group_struct *grp, struct adios_var_struct *var) {
int i, new_ndim, new_time_dim_pos;
uint64_t ldims[3];
uint64_t gdims[3];
uint64_t odims[3];
int orig_ndim = count_dimensions(var->pre_transform_dimensions);
int orig_time_dim_pos = find_time_dimension_old(var->pre_transform_dimensions, NULL, grp->adios_host_language_fortran);
assert(orig_time_dim_pos == -1 || orig_time_dim_pos == 0 || orig_time_dim_pos == orig_ndim - 1); // Time dimension is either first, last, or non-existant
ldims[0] = 1; // 1 PG ID in length
ldims[1] = 0; // unknown bytes in length
gdims[0] = UINT64_MAX >> 1; // Infinite max PGs
gdims[1] = UINT64_MAX >> 1; // Infinite max bytes
odims[0] = 0; // unknown PG ID
odims[1] = 0; // 0 byte offset
ldims[2] = gdims[2] = odims[2] = 0; // No 3rd dimension, yet
// If we are writing from a FORTRAN file, we need to reverse the raw dimensions, so that when
// it is read back it is properly swapped to C order
if (grp->adios_host_language_fortran == adios_flag_yes) {
int dummy = -1;
swap_order(2, ldims, &dummy);
swap_order(2, gdims, &dummy);
swap_order(2, odims, &dummy);
}
// Add the time dimension
if (orig_time_dim_pos == 0) {
ldims[2] = ldims[1];
ldims[1] = ldims[0];
ldims[0] = 1;
new_ndim = 3;
new_time_dim_pos = 0;
} else if (orig_time_dim_pos == orig_ndim - 1) {
ldims[2] = 1;
new_ndim = 3;
new_time_dim_pos = 2;
} else {
new_ndim = 2;
new_time_dim_pos = -1;
}
// Construct the dimension linked list
for (i = 0; i < new_ndim; i++) {
struct adios_dimension_struct *new_dim = new_dimension();
new_dim->dimension.is_time_index = (i == new_time_dim_pos) ? adios_flag_yes : adios_flag_no;
new_dim->dimension.rank = ldims[i];
new_dim->global_dimension.rank = gdims[i];
new_dim->local_offset.rank = odims[i];
adios_append_dimension(&var->dimensions, new_dim);
}
}
/*
* ordering the trucks by number of orders it has
* - the truck with more orders wants to:
* - make less time
* - do more orders
* The inter_swap objective is to make the trucks with more orders
* - less time consuming
*/
bool
Optimize::inter_swap() {
msg.log
<< "\n" <<tau("before inter swap");
delete_empty_truck();
auto swapped_f = false;
/*
* .. to ... from ....
*/
for (auto &from : fleet) {
for (auto &to : fleet) {
if (&from == &to) break;
#if 0
msg.log
<< "\n to " << to.id()
<< "from " << from.id();
auto swapped = false;
#endif
swap_worse(to, from);
swapped_f = swap_order() || swapped_f;
move_reduce_cost(from, to);
#if 0
msg.log << "++++++++" << p_swaps;
#endif
}
}
while (!p_swaps.empty()) {
swapped_f = swap_order() || swapped_f;
}
msg.log
<< "\n" <<tau("after");
delete_empty_truck();
return swapped_f;
}
bool
Optimize::swap_order() {
#if 0
msg.log << "++++++++" << p_swaps;
#endif
while (!p_swaps.empty()) {
auto swap_data = p_swaps.top();
p_swaps.pop();
size_t from_pos = 0;
size_t to_pos = 0;
for (; from_pos < fleet.size()
&& fleet[from_pos].idx() != swap_data.from_truck.idx()
; ++from_pos) {
}
pgassert(from_pos < fleet.size());
for (; to_pos < fleet.size()
&& fleet[to_pos].idx() != swap_data.to_truck.idx()
; ++to_pos) {
}
pgassert(to_pos < fleet.size());
if (swap_order(
fleet[from_pos].orders()[swap_data.from_order], fleet[from_pos],
fleet[to_pos].orders()[swap_data.to_order], fleet[to_pos])) {
save_if_best();
#if 0
msg.log
<< "\n Swapping order "
<< fleet[from_pos].orders()[
swap_data.from_order].pickup().original_id()
<< " from truck " << fleet[from_pos].id()
<< " with order "
<< fleet[to_pos].orders()[
swap_data.to_order].pickup().original_id()
<< " of truck " << fleet[to_pos].id();
#endif
#if 0
msg.log << "\nswappping after:";
msg.log << "\n" << fleet[to_pos].tau();
msg.log << "\n" << fleet[from_pos].tau();
#endif
return true;
}
}
return false;
}
void CCellView::Read(BPositionIO& stream)
{
CSwapStream str(stream);
scChunk chunk;
long offset;
int *funcList, *styleList, *fontList, *formatList;
int funcCount, styleCount, fontCount, formatCount, borderFont = fBorderFontID;
bool warnForIncorrectFormula = true;
scCell cl;
styleCount = 0;
styleList = (int *)MALLOC(0);
fontCount = 0;
fontList = (int *)MALLOC(0);
formatCount = 0;
formatList = (int *)MALLOC(0);
funcList = NULL;
scCSElement *colStyles = NULL;
int colStyleCount = 0;
offset = 0;
StProgress progress(this, 1, pColorYellow, false);
StWriteLock lock(fContainer);
try
{
stream.Seek(offset, SEEK_SET);
str >> chunk;
if (chunk.type == kscVersion)
{
scVersion vers;
str >> vers;
if (vers.major != 3)
THROW((errTooNewFileFormat));
}
else
THROW((errUnknownFileFormat, ((CCellWindow *)Window())->EntryRef()->name));
do
{
if (stream.Seek(offset, SEEK_SET) < offset)
{
MStopAlert("File is too short").Go();
break;
}
str >> chunk;
offset += 4 + chunk.size;
switch (chunk.type)
{
case kscVersion:
break;
case kscHeader:
{
scHeader head;
str >> head;
funcList = (int *)CALLOC(head.functionCount, sizeof(int));
FailNil(funcList);
funcCount = head.functionCount;
progress.NewMax(head.cellCount);
break;
}
case kscView:
{
scView view;
str >> view;
if (view.windowRect.left > 0 && view.windowRect.top > 0)
{
BRect r;
{
r = BScreen().Frame();
}
r.InsetBy(4, 4);
r = r & view.windowRect;
if (r.IsValid() && r.Width() >= 300 && r.Height() >= 100)
{
Window()->MoveTo(r.left, r.top);
Window()->ResizeTo(r.Width(), r.Height());
}
}
if (view.position.h > 0 && view.position.v > 0)
fPosition = view.position;
fFrozen = view.frozen;
if (view.selection.IsValid())
fSelection = view.selection;
if (fSelection.Contains(view.curCell))
fCurCell = view.curCell;
borderFont = view.headingFont;
fShowGrid = (view.flags & kscShowGrid) != 0;
fShowBorders = (view.flags & kscShowHeadings) != 0;
if (!fShowBorders)
{
fCellBounds.left -= fBorderWidth;
fCellBounds.top -= fBorderHeight;
}
Window()->Show();
Window()->UpdateIfNeeded();
break;
}
case kscPrint:
break;
case kscWidths:
case kscHeights:
{
int count = chunk.size/(sizeof(short)*2);
scWidthElement *elems = (scWidthElement *)MALLOC(chunk.size);
FailNil(elems);
int k = count * sizeof(scWidthElement);
stream.Read(elems, k);
if (chunk.type == kscWidths)
fCellWidths.Read(count, elems);
else
fCellHeights.Read(count, elems);
FREE(elems);
break;
}
case kscColStyles:
{
colStyleCount = chunk.size/(sizeof(short)*2);
colStyles = (scCSElement *)MALLOC(chunk.size);
FailNil(colStyles);
for (int i = 0; i < colStyleCount; i++)
str >> colStyles[i];
break;
}
case kscName:
{
char buf[50];
scName *name = (scName *)buf;
int l = std::min((int)chunk.size, 50);
stream.Read(name, l);
range r;
memcpy(&r, name->reference+1, sizeof(cell));
if (name->reference[0] == valRange)
memcpy(&r.bottom, name->reference+5, sizeof(cell));
else
r.BotRight() = r.TopLeft();
swap_order(r);
if (fNames->count(name->name) == 0)
(*fNames)[CName(name->name)] = r;
break;
}
case kscFunc:
{
scFunc func;
str >> func;
if (!funcList) THROW((errCorruptedFile));
if (func.funcNr >= funcCount)
THROW((errCorruptedFile));
funcList[func.funcNr] = GetFunctionNr(func.name);
if (funcList[func.funcNr] == -1)
WarnForMissingFunction(func.name);
break;
}
case kscFont:
{
scFont font;
str >> font;
font_family fam;
font_style sty;
ReadCString(stream, sizeof(font_style), sty);
ReadCString(stream, sizeof(font_family), fam);
int *t = (int *)REALLOC(fontList, (fontCount+1)*sizeof(int));
FailNil(t);
fontList = t;
fontList[fontCount] = gFontSizeTable.GetFontID(
fam, sty, font.size, font.color);
fontCount++;
break;
}
case kscFormat:
{
scFormat format;
str >> format;
int *t = (int *)REALLOC(formatList, (formatCount+1)*sizeof(int));
FailNil(t);
formatList = t;
if (format.nr < eFirstNewFormat)
formatList[formatCount] = format.nr;
else
{
char fs[256];
ReadCString(stream, 255, fs);
formatList[formatCount] = gFormatTable.GetFormatID(fs);
}
formatCount++;
break;
}
case kscStyle:
{
scStyle style;
str >> style;
int *t = (int *)REALLOC(styleList, (styleCount+1)*sizeof(int));
FailNil(t);
styleList = t;
CellStyle cs;
if (style.font >= fontCount)
THROW((errCorruptedFile));
cs.fFont = fontList[style.font];
if (style.format >= formatCount)
THROW((errCorruptedFile));
cs.fFormat = formatList[style.format];
cs.fAlignment = style.align;
cs.fLowColor = style.lowColor;
cs.fLocked = (style.flags & kscLocked) != 0;
cs.fHidden = (style.flags & kscHidden) != 0;
styleList[styleCount] = gStyleTable.GetStyleID(cs);
styleCount++;
break;
}
case kscCellEmpty:
case kscCellBool:
case kscCellNumber:
case kscCellDateTime:
case kscCellText:
{
str >> cl;
Value val;
switch (chunk.type)
{
case kscCellBool:
{
bool b;
str >> b;
val = b;
break;
}
case kscCellNumber:
{
double d;
str >> d;
val = d;
break;
}
case kscCellDateTime:
{
time_t t;
str >> t;
val = t;
break;
}
case kscCellText:
{
// do nothing yet...
}
}
fContainer->NewCell(cl.loc, val, NULL);
if (cl.style >= styleCount)
/*THROW((errCorruptedFile))*/;
else
fContainer->SetCellStyleNr(cl.loc, styleList[cl.style]);
progress.Step();
break;
}
case kscString:
{
char s[256];
Value val;
stream.Read(s, std::min((int)chunk.size, 255));
s[std::min((int)chunk.size, 255)] = 0;
val = s;
fContainer->SetValue(cl.loc, val);
break;
}
case kscFormula:
{
CFormula form;
try
{
if (!funcList) THROW((errCorruptedFile));
form.Read(stream, funcList);
Value v;
form.Calculate(cl.loc, v, fContainer);
fContainer->SetCellFormula(cl.loc, form.CopyString());
}
catch (CErr& e)
{
CATCHED;
char s[32];
cl.loc.GetName(s);
#if DEBUG
printf("%s in formula of cell %s\n", (char *)e, s);
#endif
if (warnForIncorrectFormula)
{
char m[256];
sprintf(m, GetMessage(msgIncorrectFormula), s);
MAlert *a = new MWarningAlert(m, GetMessage(msgOK),
GetMessage(msgNoMoreWarnings));
if (a->Go() == 2)
warnForIncorrectFormula = false;
}
}
form.Clear();
break;
}
case kscChart:
ReadChart(stream, chunk.size);
case kscEnd:
break;
default:
MStopAlert("File contains errors").Go();
chunk.type = kscEnd;
break;
}
}
while (chunk.type != kscEnd);
// adjust the fields that couldn't be adjusted before
if (fontCount && borderFont < fontCount)
fBorderFontID = fontList[borderFont];
if (colStyles && styleList)
{
for (int i = 0; i < colStyleCount; i++)
{
if (colStyles[i].style >= 0 && colStyles[i].style < styleCount)
colStyles[i].style = styleList[colStyles[i].style];
}
fContainer->GetColumnStyles().Read(colStyleCount, colStyles);
}
}
void CCellView::Write(BPositionIO& stream)
{
// Collect the information needed to write the file, fonts first...
int *fontList, usedFonts;
fontList = (int *)MALLOC(gFontSizeTable.Count() * sizeof(int));
FailNil(fontList);
usedFonts = fContainer->CollectFontList(fontList);
if (GetOffsetOf(fontList, fBorderFontID, usedFonts) == -1)
fontList[usedFonts++] = fBorderFontID;
// ...then the styles
int *styleList, usedStyles;
styleList = (int *)CALLOC(gStyleTable.Count(), sizeof(int));
FailNil(styleList);
usedStyles = fContainer->CollectStyles(styleList);
// Write the version number
scVersion vers;
vers.major = 3;
vers.minor = 0;
WriteChunk(stream, kscVersion, sizeof(vers), &vers);
// Write some header info, global to the document
scHeader head;
head.defaultFormat = 0;
head.flags = htonl(fAutoRecalc ? kscAutoRecalc : 0);
head.functionCount = htons(gFuncCount);
head.cellCount = htonl(fContainer->GetCellCount());
WriteChunk(stream, kscHeader, sizeof(head), &head);
// Write a view
scView view;
view.windowRect = Window()->Frame(); swap_order(view.windowRect);
view.position = fPosition; swap_order(view.position);
view.frozen = fFrozen; swap_order(view.frozen);
view.curCell = fCurCell; swap_order(view.curCell);
view.selection = fSelection; swap_order(view.selection);
view.headingFont = htons(GetOffsetOf(fontList, fBorderFontID, usedFonts));
if (fShowGrid) view.flags |= kscShowGrid;
if (fShowBorders) view.flags |= kscShowHeadings;
if (fDisplayZero) view.flags |= kscDisplayZero; swap_order(view.flags);
WriteChunk(stream, kscView, sizeof(view), &view);
short size;
// Write the widths of the last view
size = fCellWidths.Count() * sizeof(short) * 2;
void *p = MALLOC(size);
FailNil(p);
fCellWidths.Write(p);
WriteChunk(stream, kscWidths, size, p);
FREE(p);
// And the heights of course
size = fCellHeights.Count() * sizeof(short) * 2;
p = MALLOC(size);
FailNil(p);
fCellHeights.Write(p);
WriteChunk(stream, kscHeights, size, p);
FREE(p);
// Then write the styles for the columns
size = fContainer->GetColumnStyles().Count() * sizeof(short) * 2;
p = MALLOC(size);
FailNil(p);
scCSElement *sp = (scCSElement *)p;
fContainer->GetColumnStyles().Write(p);
for (int i = 0; i < fContainer->GetColumnStyles().Count(); i++)
{
swap_order(sp[i].index);
sp[i].style = htons(GetOffsetOf(styleList, sp[i].style, usedStyles));
}
WriteChunk(stream, kscColStyles, size, p);
FREE(p);
// Continue with the names
namemap::iterator ni;
for (ni = fNames->begin(); ni != fNames->end(); ni++)
{
scName name;
char c;
ushort k = htons(kscName);
memset(name.name, 0, 32);
CHECKWRITE(stream, &k, 2);
strcpy(name.name, (*ni).first);
if ((*ni).second.BotRight() == (*ni).second.TopLeft())
{
k = htons(32 + 6);
CHECKWRITE(stream, &k, 2);
CHECKWRITE(stream, name.name, 32);
c = valCell;
CHECKWRITE(stream, &c, sizeof(c));
cell C = (*ni).second.BotRight();
swap_order(C);
CHECKWRITE(stream, &C, sizeof(cell));
}
else
{
k = htons(32 + 10);
CHECKWRITE(stream, &k, 2);
CHECKWRITE(stream, name.name, 32);
c = valRange;
CHECKWRITE(stream, &c, sizeof(c));
range r = (*ni).second;
swap_order(r);
CHECKWRITE(stream, &r, sizeof(range));
}
c = opEnd;
CHECKWRITE(stream, &c, sizeof(c));
}
// Then there are the functions used in this document
CSet funcs;
fContainer->CollectFunctionNrs(funcs);
for (int i = kFunctionCount; i < gFuncCount; i++)
if (funcs[i])
{
scFunc func;
memset(func.name, 0, 10);
strcpy(func.name, gFuncArrayByNr[i].funcName);
func.argCnt = htons(gFuncArrayByNr[i].argCnt);
func.funcNr = htons(gFuncArrayByNr[i].funcNr);
WriteChunk(stream, kscFunc, sizeof(func), &func);
}
// Followed by the formatting information. Fonts first
for (int i = 0; i < usedFonts; i++)
{
CFontMetrics fm = gFontSizeTable[fontList[i]];
scFont *font;
font_family fam;
font_style sty;
fm.Font().GetFamilyAndStyle(&fam, &sty);
ulong size = sizeof(scFont) + strlen(fam) + strlen(sty) + 2;
font = (scFont *)CALLOC(1, size);
FailNil(font);
font->size = B_HOST_TO_BENDIAN_FLOAT(fm.Font().Size());
font->color = fm.FontColor();
char *p = (char *)font + sizeof(scFont);
strcpy(p, sty);
p += strlen(sty) + 1;
strcpy(p, fam);
WriteChunk(stream, kscFont, size, font);
FREE(font);
}
// Then we get the number formats
int *formatList, usedFormats;
formatList = (int *)MALLOC(gFormatTable.Count() * sizeof(int));
FailNil(formatList);
usedFormats = fContainer->CollectFormats(formatList);
for (int i = 0; i < usedFormats; i++)
{
CFormatter nf;
if (formatList[i] < eFirstNewFormat)
nf = CFormatter(formatList[i]);
else
nf = gFormatTable[formatList[i]];
scFormat format;
format.nr = htons(nf.FormatID());
format.info[0] = 0;
format.info[1] = 0;
format.info[2] = 0;
format.info[3] = 0;
WriteChunk(stream, kscFormat, sizeof(format)-1, &format);
}
// The style table
for (int i = 0; i < usedStyles; i++)
{
CellStyle cs = gStyleTable[styleList[i]];
scStyle style;
memset(&style, 0, sizeof(style));
style.font = htons(GetOffsetOf(fontList, cs.fFont, usedFonts));
style.format = htons(GetOffsetOf(formatList, cs.fFormat, usedFormats));
style.align = cs.fAlignment;
style.lowColor = cs.fLowColor;
WriteChunk(stream, kscStyle, sizeof(style), &style);
}
FREE(fontList);
FREE(formatList);
int *t = (int *)CALLOC(gStyleTable.Count(), sizeof(int));
FailNil(t);
for (int i = 0; i < usedStyles; i++)
t[styleList[i]] = i;
FREE(styleList);
styleList = t;
// And now its time for some data
StProgress progress(this, fContainer->GetCellCount(), pColorYellow, false);
CCellIterator iter(fContainer);
cell c;
while (iter.NextExisting(c))
{
scCell cl;
cl.loc = c; swap_order(cl.loc);
cl.style = htons(styleList[fContainer->GetCellStyleNr(c)]);
Value val;
fContainer->GetValue(c, val);
switch (val.fType)
{
case eNoData:
WriteChunk(stream, kscCellEmpty, kscCellSize, &cl);
break;
case eNumData:
{
double d = B_HOST_TO_BENDIAN_DOUBLE(val.fDouble);
memcpy(cl.num, &d, sizeof(double));
WriteChunk(stream, kscCellNumber, kscCellSize+sizeof(double), &cl);
break;
}
case eBoolData:
memcpy(cl.num, &val.fBool, sizeof(bool));
WriteChunk(stream, kscCellBool, kscCellSize+sizeof(bool), &cl);
break;
case eTimeData:
{
time_t t = htonl(val.fTime);
memcpy(cl.num, &t, sizeof(time_t));
WriteChunk(stream, kscCellDateTime, kscCellSize+sizeof(time_t), &cl);
break;
}
case eTextData:
{
WriteChunk(stream, kscCellText, kscCellSize, &cl);
const char *t = val;
WriteChunk(stream, kscString, strlen(t) + 1, t);
break;
}
default:
// there was a warning about not all enum values handled in
// switch statement.
break;
}
CFormula form = fContainer->GetCellFormula(c);
if (form.IsFormula())
{
BMallocIO buf;
form.Write(buf);
WriteChunk(stream, kscFormula, buf.BufferLength(), buf.Buffer());
}
progress.Step();
}
WriteCharts(stream);
// cleanup the mess
WriteChunk(stream, kscEnd, 0, NULL);
FREE(styleList);
}
bool
Optimize::swap_worse(size_t from_pos, size_t to_pos) {
pgassert(to_pos < from_pos);
auto from_truck = fleet[from_pos];
auto to_truck = fleet[to_pos];
auto swapped(false);
auto from_orders(from_truck.orders_in_vehicle);
auto to_orders(to_truck.orders_in_vehicle);
auto local_limit(from_orders.size() * to_orders.size() + 1);
while (!from_orders.empty() && --local_limit > 0) {
auto from_order(from_truck.get_worse_order(from_orders));
from_orders.erase(from_order.id());
while (!to_orders.empty()) {
auto to_order(to_truck.get_worse_order(to_orders));
to_orders.erase(to_order.id());
/*
* delete from_order, and to order from their trucks
*/
auto curr_from_duration(from_truck.duration());
auto curr_to_duration(to_truck.duration());
from_truck.erase(from_order);
to_truck.erase(to_order);
/*
* insert them in the other truck
*/
from_truck.insert(to_order);
to_truck.insert(from_order);
if (from_truck.is_feasable() && to_truck.is_feasable()) {
/*
* Can swap but:
* - only swap when the total duration is reduced
* - or from_truck duration is reduced
*/
if (((from_truck.duration() + to_truck.duration())
< (curr_from_duration + curr_to_duration))
|| (from_truck.duration() < curr_from_duration)) {
problem->log
<< "\n Swap order " << from_order.id()
<< " from truck " << from_truck.id()
<< " with order " << to_order.id() << " of truck " << to_truck.id();
#ifndef NDEBUG
problem->dbg_log << "\nswappping before:";
problem->dbg_log << "\n" << fleet[to_pos].tau();
problem->dbg_log << "\n" << fleet[from_pos].tau();
#endif
swap_order(from_order, fleet[from_pos], to_order, fleet[to_pos]);
swapped = true;
save_if_best();
from_orders.insert(to_order.id());
#ifndef NDEBUG
problem->dbg_log << "\nswappping after:";
problem->dbg_log << "\n" << fleet[to_pos].tau();
problem->dbg_log << "\n" << fleet[from_pos].tau();
#endif
break;
}
}
/*
* wasn't swapped
*/
to_truck = fleet[to_pos];
from_truck = fleet[from_pos];
}
}
return swapped;
}
void byte_order_helper::order_native_to_le(void * ptr,unsigned bytes)
{
if (machine_is_big_endian()) swap_order(ptr,bytes);
}
void byte_order_helper::order_native_to_le(void * ptr,unsigned bytes)
{
#if PFC_BYTE_ORDER_IS_BIG_ENDIAN
swap_order(ptr,bytes);
#endif
}
void swap_spin_in_vector(double* data_pt, int size) {
swap_order(data_pt, size, 6, 4);
}
void swap_spin_in_conf(double* data_pt, int size) {
swap_order(data_pt, size, 18, 4);
}
