// Write-lock & delete 'k'. Will fail if 'k' is locked by anybody other than 'job_key'
public static void delete(Key k, Key job_key) {
if (k == null) return;
Value val = DKV.get(k);
if (val == null) return; // Or just nothing there to delete
if (!val.isLockable()) UKV.remove(k); // Simple things being deleted
else ((Lockable) val.get()).delete(job_key, 0.0f); // Lockable being deleted
}
@Override
public JsonElement serialize(GraphObject src, Type typeOfSrc, JsonSerializationContext context) {
String localPropertyView = propertyView.get(null);
JsonElement serializedOutput = null;
switch (propertyFormat) {
case NestedKeyValueType:
serializedOutput =
serializeNestedKeyValueType(src, typeOfSrc, context, true, localPropertyView, 0);
break;
case NestedKeyValue:
serializedOutput =
serializeNestedKeyValueType(src, typeOfSrc, context, false, localPropertyView, 0);
break;
case FlatNameValue:
serializedOutput = serializeFlatNameValue(src, typeOfSrc, context, localPropertyView, 0);
break;
}
return serializedOutput;
}
@Override
public GraphObject deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException {
String localPropertyView = propertyView.get(null);
GraphObject deserializedOutput = null;
switch (propertyFormat) {
case NestedKeyValueType:
deserializedOutput =
deserializeNestedKeyValueType(json, typeOfT, context, true, localPropertyView, 0);
break;
case NestedKeyValue:
deserializedOutput =
deserializeNestedKeyValueType(json, typeOfT, context, false, localPropertyView, 0);
break;
case FlatNameValue:
deserializedOutput = deserializeFlatNameValue(json, typeOfT, context, localPropertyView, 0);
break;
}
return deserializedOutput;
}
@Override
public int compareTo(@NonNull @Nonnull final Value<UUID> other) {
UUID thisValue = get();
UUID otherValue = other.get();
return thisValue.compareTo(otherValue);
}
/**
* The list of all Jobs, past and present.
*
* @return The list of all Jobs, past and present
*/
public static Job[] jobs() {
final Value val = DKV.get(LIST);
if (val == null) return new Job[0];
JobList jl = val.get();
Job[] jobs = new Job[jl._jobs.length];
int j = 0;
for (int i = 0; i < jl._jobs.length; i++) {
final Value job = DKV.get(jl._jobs[i]);
if (job != null) jobs[j++] = job.get();
}
if (j == jobs.length) return jobs; // All jobs still exist
jobs = Arrays.copyOf(jobs, j); // Shrink out removed
Key keys[] = new Key[j];
for (int i = 0; i < j; i++) keys[i] = jobs[i]._key;
// One-shot throw-away attempt at remove dead jobs from the jobs list
DKV.DputIfMatch(LIST, new Value(LIST, new JobList(keys)), val, new Futures());
return jobs;
}
public static ModelMetrics getFromDKV(UniqueId model, UniqueId frame) {
Key metricsKey = buildKey(model, frame);
Log.debug("Getting ModelMetrics: " + metricsKey.toString());
Value v = DKV.get(metricsKey);
if (null == v) return null;
return (ModelMetrics) v.get();
}
public void onException(Throwable ex) {
UKV.remove(dest());
Value v = DKV.get(progressKey());
if( v != null ) {
ChunkProgress p = v.get();
p = p.error(ex.getMessage());
DKV.put(progressKey(), p);
}
cancel(ex);
}
/**
* Initialize the ModelBuilder, validating all arguments and preparing the training frame. This
* call is expected to be overridden in the subclasses and each subclass will start with
* "super.init();". This call is made by the front-end whenever the GUI is clicked, and needs to
* be fast; heavy-weight prep needs to wait for the trainModel() call.
*
* <p>Validate the requested ntrees; precompute actual ntrees. Validate the number of classes to
* predict on; validate a checkpoint.
*/
@Override
public void init(boolean expensive) {
super.init(expensive);
if (H2O.ARGS.client && _parms._build_tree_one_node)
error("_build_tree_one_node", "Cannot run on a single node in client mode");
if (_vresponse != null) _vresponse_key = _vresponse._key;
if (_response != null) _response_key = _response._key;
if (_parms._min_rows < 0) error("_min_rows", "Requested min_rows must be greater than 0");
if (_parms._ntrees < 0 || _parms._ntrees > MAX_NTREES)
error("_ntrees", "Requested ntrees must be between 1 and " + MAX_NTREES);
_ntrees = _parms._ntrees; // Total trees in final model
if (_parms.hasCheckpoint()) { // Asking to continue from checkpoint?
Value cv = DKV.get(_parms._checkpoint);
if (cv != null) { // Look for prior model
M checkpointModel = cv.get();
try {
_parms.validateWithCheckpoint(checkpointModel._parms);
} catch (H2OIllegalArgumentException e) {
error(e.values.get("argument").toString(), e.values.get("value").toString());
}
if (_parms._ntrees < checkpointModel._output._ntrees + 1)
error(
"_ntrees",
"If checkpoint is specified then requested ntrees must be higher than "
+ (checkpointModel._output._ntrees + 1));
// Compute number of trees to build for this checkpoint
_ntrees = _parms._ntrees - checkpointModel._output._ntrees; // Needed trees
}
}
if (_parms._nbins <= 1) error("_nbins", "_nbins must be > 1.");
if (_parms._nbins >= 1 << 16) error("_nbins", "_nbins must be < " + (1 << 16));
if (_parms._nbins_cats <= 1) error("_nbins_cats", "_nbins_cats must be > 1.");
if (_parms._nbins_cats >= 1 << 16) error("_nbins_cats", "_nbins_cats must be < " + (1 << 16));
if (_parms._max_depth <= 0) error("_max_depth", "_max_depth must be > 0.");
if (_parms._min_rows <= 0) error("_min_rows", "_min_rows must be > 0.");
if (_train != null) {
double sumWeights =
_train.numRows() * (hasWeightCol() ? _train.vec(_parms._weights_column).mean() : 1);
if (sumWeights
< 2 * _parms._min_rows) // Need at least 2*min_rows weighted rows to split even once
error(
"_min_rows",
"The dataset size is too small to split for min_rows="
+ _parms._min_rows
+ ": must have at least "
+ 2 * _parms._min_rows
+ " (weighted) rows, but have only "
+ sumWeights
+ ".");
}
if (_train != null) _ncols = _train.numCols() - 1 - numSpecialCols();
}
/**
* Initialize the ModelBuilder, validating all arguments and preparing the training frame. This
* call is expected to be overridden in the subclasses and each subclass will start with
* "super.init();". This call is made by the front-end whenever the GUI is clicked, and needs to
* be fast; heavy-weight prep needs to wait for the trainModel() call.
*
* <p>Validate the requested ntrees; precompute actual ntrees. Validate the number of classes to
* predict on; validate a checkpoint.
*/
@Override
public void init(boolean expensive) {
super.init(expensive);
if (H2O.ARGS.client && _parms._build_tree_one_node)
error("_build_tree_one_node", "Cannot run on a single node in client mode");
if (_vresponse != null) _vresponse_key = _vresponse._key;
if (_response != null) _response_key = _response._key;
if (_nclass > SharedTreeModel.SharedTreeParameters.MAX_SUPPORTED_LEVELS)
error("_nclass", "Too many levels in response column!");
if (_parms._min_rows < 0) error("_min_rows", "Requested min_rows must be greater than 0");
if (_parms._ntrees < 0 || _parms._ntrees > 100000)
error("_ntrees", "Requested ntrees must be between 1 and 100000");
_ntrees = _parms._ntrees; // Total trees in final model
if (_parms._checkpoint) { // Asking to continue from checkpoint?
Value cv = DKV.get(_parms._model_id);
if (cv != null) { // Look for prior model
M checkpointModel = cv.get();
if (_parms._ntrees < checkpointModel._output._ntrees + 1)
error(
"_ntrees",
"Requested ntrees must be between "
+ checkpointModel._output._ntrees
+ 1
+ " and 100000");
_ntrees = _parms._ntrees - checkpointModel._output._ntrees; // Needed trees
}
}
if (_parms._nbins <= 1) error("_nbins", "_nbins must be > 1.");
if (_parms._nbins >= 1 << 16) error("_nbins", "_nbins must be < " + (1 << 16));
if (_parms._nbins_cats <= 1) error("_nbins_cats", "_nbins_cats must be > 1.");
if (_parms._nbins_cats >= 1 << 16) error("_nbins_cats", "_nbins_cats must be < " + (1 << 16));
if (_parms._max_depth <= 0) error("_max_depth", "_max_depth must be > 0.");
if (_parms._min_rows <= 0) error("_min_rows", "_min_rows must be > 0.");
if (_parms._distribution == Distributions.Family.tweedie) {
_parms._distribution.tweedie.p = _parms._tweedie_power;
}
if (_train != null) {
double sumWeights =
_train.numRows() * (hasWeightCol() ? _train.vec(_parms._weights_column).mean() : 1);
if (sumWeights
< 2 * _parms._min_rows) // Need at least 2*min_rows weighted rows to split even once
error(
"_min_rows",
"The dataset size is too small to split for min_rows="
+ _parms._min_rows
+ ": must have at least "
+ 2 * _parms._min_rows
+ " (weighted) rows, but have only "
+ sumWeights
+ ".");
}
if (_train != null) _ncols = _train.numCols() - 1 - numSpecialCols();
}
/** Returns the trace. */
public static Value getTraceAsString(Env env, @This Value obj) {
Value trace = getTrace(env, obj);
StringValue sb = new StringValue();
sb.append("<trace>");
Iterator<Value> iter = trace.getValueIterator(env);
while (iter.hasNext()) {
Value value = iter.next();
sb = sb.append('\n');
sb = sb.append(value.get(FILE));
sb = sb.append(':');
sb = sb.append(value.get(LINE));
sb = sb.append(": ");
sb = sb.append(value.get(FUNCTION));
}
return sb;
}
/** @return Calculates the maximum value based on the item's values for the given dimension. */
private double calcMax() {
double savedMax = 0;
for (Item i : itemList) {
for (Value v : i.getValueList()) {
double currentMax = v.get(dimension);
if (currentMax > savedMax) {
savedMax = currentMax;
}
}
}
return savedMax;
}
@Test
public void testAsSetAction() throws Exception {
final Value<String> value = Value.create("1");
assertEquals(value.get(), "1");
TestSubscriber<String> testSubscriber = new TestSubscriber<>();
Subscription subscribe = value.asObservable().subscribe(testSubscriber);
value.asSetAction().call("2");
testSubscriber.assertValueCount(2);
testSubscriber.assertValues("1", "2");
}
/** @return Calculates the minimum value based on the item's values for the given dimension. */
private double calcMin() {
double savedMin = 0;
for (Item i : itemList) {
for (Value v : i.getValueList()) {
double currentMin = v.get(dimension);
if (currentMin < savedMin) {
savedMin = currentMin;
}
}
}
return savedMin;
}
// TODO: almost identical to ModelsHandler; refactor
public static ModelMetrics getFromDKV(Key key) {
if (null == key) throw new IllegalArgumentException("Got null key.");
Value v = DKV.get(key);
if (null == v) throw new IllegalArgumentException("Did not find key: " + key.toString());
Iced ice = v.get();
if (!(ice instanceof ModelMetrics))
throw new IllegalArgumentException(
"Expected a Model for key: " + key.toString() + "; got a: " + ice.getClass());
return (ModelMetrics) ice;
}
@Override
protected Key parse(String input) {
if (_validator != null) _validator.validateRaw(input);
Key k = Key.make(input);
Value v = DKV.get(k);
if (v == null && _mustExist)
throw new IllegalArgumentException("Key '" + input + "' does not exist!");
if (_type != null) {
if (v != null && !compatible(_type, v.get()))
throw new IllegalArgumentException(input + ":" + errors()[0]);
if (v == null && _required)
throw new IllegalArgumentException("Key '" + input + "' does not exist!");
}
return k;
}
/**
* Build the command
*
* @param streams The input streams
* @param task The task
* @param simulate True if in simulation mode (no action is taken)
* @return The command to execute
*/
public Commands commands(HashMap<Object, CommandOutput> streams, Task task, boolean simulate) {
// Add our command
Commands commands = build(task);
// Add dependencies
if (!simulate) {
for (Value value : task.getValues().values()) {
Json element = value.get();
fillDependencies(commands, element, value.nestedDependencies() ? Integer.MAX_VALUE : 1);
}
}
return commands;
}
public static String store2Hdfs(Key srcKey) {
assert srcKey._kb[0] != Key.ARRAYLET_CHUNK;
assert PersistHdfs.getPathForKey(srcKey) != null; // Validate key name
Value v = DKV.get(srcKey);
if (v == null) return "Key " + srcKey + " not found";
if (!v.isArray()) { // Simple chunk?
v.setHdfs(); // Set to HDFS and be done
return null; // Success
}
// For ValueArrays, make the .hex header
ValueArray ary = v.get();
String err = PersistHdfs.freeze(srcKey, ary);
if (err != null) return err;
// The task managing which chunks to write next,
// store in a known key
TaskStore2HDFS ts = new TaskStore2HDFS(srcKey);
Key selfKey = ts.selfKey();
UKV.put(selfKey, ts);
// Then start writing chunks in-order with the zero chunk
H2ONode chk0_home = ValueArray.getChunkKey(0, srcKey).home_node();
RPC.call(ts.chunkHome(), ts);
// Watch the progress key until it gets removed or an error appears
long idx = 0;
while ((ts = UKV.get(selfKey, TaskStore2HDFS.class)) != null) {
if (ts._indexFrom != idx) {
System.out.print(" " + idx + "/" + ary.chunks());
idx = ts._indexFrom;
}
if (ts._err != null) { // Found an error?
UKV.remove(selfKey); // Cleanup & report
return ts._err;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
System.out.println(" " + ary.chunks() + "/" + ary.chunks());
// PersistHdfs.refreshHDFSKeys();
return null;
}
/**
* <p>
* Decodes the content of the supplied <code>ValueState</code> as an array
* of Objects. Usually this array has one element containing the single
* Object value encoded in the <code>ValueState</code>. However, if multiple
* items were written to the original <code>Value</code> from which the
* <code>ValueState</code> was derived in
* <a href="com.persistit.Value.html#_streamMode">Stream Mode</a>, this
* method returns all of the encoded objects.
* </p>
* <p>
* If the <code>valueState</code> represents an undefined value, this method
* returns an array of length zero. If the <code>valueState</code> encodes
* a value of <code>null</code>, then this method returns an array containing
* one element which is <code>null</code>.
* </p>
*
* @param valueState Representation of an encoded {@link Value).
*
* @param context Object passed to any {@link ValueCoder} used in
* decoding the value. May be <code>null</code>
*
* @return Array of zero or more Objects encoded
* in the <code>ValueState</code>
* @throws RemoteException
*/
@Override
public Object[] decodeValueObjects(final ValueState valueState, final CoderContext context)
throws RemoteException {
try {
final Value value = new Value(_persistit);
valueState.copyTo(value);
value.setStreamMode(true);
final Vector vector = new Vector();
while (value.hasMoreItems()) {
vector.addElement(value.get(null, context));
}
final Object[] result = new Object[vector.size()];
for (int index = 0; index < result.length; index++) {
result[index] = vector.get(index);
}
return result;
} catch (final Exception e) {
throw new WrappedRemoteException(e);
}
}
@SuppressWarnings("unused") // called through reflection by RequestServer
public JobsV3 fetch(int version, JobsV3 s) {
Key key = s.job_id.key();
Value val = DKV.get(key);
if (null == val) throw new IllegalArgumentException("Job is missing");
Iced ice = val.get();
if (!(ice instanceof Job))
throw new IllegalArgumentException("Must be a Job not a " + ice.getClass());
Job j = (Job) ice;
s.jobs = new JobV3[1];
// s.fillFromImpl(jobs);
try {
s.jobs[0] = (JobV3) Schema.schema(version, j).fillFromImpl(j);
}
// no special schema for this job subclass, so fall back to JobV3
catch (H2ONotFoundArgumentException e) {
s.jobs[0] = new JobV3().fillFromImpl(j);
}
return s;
}
@Test
public void testCreatePublish() throws Exception {
final Value<String> value = Value.createPublish("1");
assertEquals(value.get(), "1");
TestSubscriber<String> testSubscriber = new TestSubscriber<>();
Subscription subscribe = value.asObservable().subscribe(testSubscriber);
testSubscriber.assertValueCount(0);
value.set("2");
testSubscriber.assertValueCount(1);
testSubscriber.assertValues("2");
subscribe.unsubscribe();
testSubscriber = new TestSubscriber<>();
value.asObservable().subscribe(testSubscriber);
testSubscriber.assertValueCount(0);
}
static boolean checkSaneFrame_impl() {
for (Key k : H2O.localKeySet()) {
Value val = H2O.raw_get(k);
if (val.isFrame()) {
Frame fr = val.get();
Vec vecs[] = fr.vecs();
for (int i = 0; i < vecs.length; i++) {
Vec v = vecs[i];
if (DKV.get(v._key) == null) {
System.err.println(
"Frame "
+ fr._key
+ " in the DKV, is missing Vec "
+ v._key
+ ", name="
+ fr._names[i]);
return false;
}
}
}
}
return true;
}
/**
* Copy properties "of the same name" from one POJO to the other. If the fields are named
* consistently (both sides have fields named "_foo" and/or "bar") this acts like Apache Commons
* PojoUtils.copyProperties(). If one side has leading underscores and the other does not then the
* names are conformed according to the field_naming parameter.
*
* @param dest Destination POJO
* @param origin Origin POJO
* @param field_naming Are the fields named consistently, or does one side have underscores?
* @param skip_fields Array of origin or destination field names to skip
* @param only_fields Array of origin or destination field names to include; ones not in this list
* will be skipped
*/
public static void copyProperties(
Object dest,
Object origin,
FieldNaming field_naming,
String[] skip_fields,
String[] only_fields) {
if (null == dest || null == origin) return;
Field[] dest_fields = Weaver.getWovenFields(dest.getClass());
Field[] orig_fields = Weaver.getWovenFields(origin.getClass());
for (Field orig_field : orig_fields) {
String origin_name = orig_field.getName();
if (skip_fields != null & ArrayUtils.contains(skip_fields, origin_name)) continue;
if (only_fields != null & !ArrayUtils.contains(only_fields, origin_name)) continue;
String dest_name = null;
if (field_naming == FieldNaming.CONSISTENT) {
dest_name = origin_name;
} else if (field_naming == FieldNaming.DEST_HAS_UNDERSCORES) {
dest_name = "_" + origin_name;
} else if (field_naming == FieldNaming.ORIGIN_HAS_UNDERSCORES) {
dest_name = origin_name.substring(1);
}
if (skip_fields != null & ArrayUtils.contains(skip_fields, dest_name)) continue;
if (only_fields != null & !ArrayUtils.contains(only_fields, dest_name)) continue;
try {
Field dest_field = null;
for (Field fd : dest_fields) {
if (fd.getName().equals(dest_name)) {
dest_field = fd;
break;
}
}
if (dest_field != null) {
dest_field.setAccessible(true);
orig_field.setAccessible(true);
// Log.info("PojoUtils.copyProperties, origin field: " + orig_field + "; destination
// field: " + dest_field);
if (null == orig_field.get(origin)) {
//
// Assigning null to dest.
//
dest_field.set(dest, null);
} else if (dest_field.getType().isArray()
&& orig_field.getType().isArray()
&& (dest_field.getType().getComponentType()
!= orig_field.getType().getComponentType())) {
//
// Assigning an array to another array.
//
// You can't use reflection to set an int[] with an Integer[]. Argh.
// TODO: other types of arrays. . .
if (dest_field.getType().getComponentType() == double.class
&& orig_field.getType().getComponentType() == Double.class) {
//
// Assigning an Double[] to an double[]
//
double[] copy = (double[]) orig_field.get(origin);
dest_field.set(dest, copy);
} else if (dest_field.getType().getComponentType() == Double.class
&& orig_field.getType().getComponentType() == double.class) {
//
// Assigning an double[] to an Double[]
//
Double[] copy = (Double[]) orig_field.get(origin);
dest_field.set(dest, copy);
} else if (dest_field.getType().getComponentType() == int.class
&& orig_field.getType().getComponentType() == Integer.class) {
//
// Assigning an Integer[] to an int[]
//
int[] copy = (int[]) orig_field.get(origin);
dest_field.set(dest, copy);
} else if (dest_field.getType().getComponentType() == Integer.class
&& orig_field.getType().getComponentType() == int.class) {
//
// Assigning an int[] to an Integer[]
//
Integer[] copy = (Integer[]) orig_field.get(origin);
dest_field.set(dest, copy);
} else if (Schema.class.isAssignableFrom(dest_field.getType().getComponentType())
&& (Schema.getImplClass(
(Class<? extends Schema>) dest_field.getType().getComponentType()))
.isAssignableFrom(orig_field.getType().getComponentType())) {
//
// Assigning an array of impl fields to an array of schema fields, e.g. a
// DeepLearningParameters[] into a DeepLearningParametersV2[]
//
Class dest_component_class = dest_field.getType().getComponentType();
Schema[] translation =
(Schema[])
Array.newInstance(
dest_component_class, Array.getLength(orig_field.get(origin)));
int i = 0;
int version = ((Schema) dest).getSchemaVersion();
// Look up the schema for each element of the array; if not found fall back to the
// schema for the base class.
for (Iced impl : ((Iced[]) orig_field.get(origin))) {
if (null == impl) {
translation[i++] = null;
} else {
Schema s = null;
try {
s = Schema.schema(version, impl);
} catch (H2ONotFoundArgumentException e) {
s = ((Schema) dest_field.getType().getComponentType().newInstance());
}
translation[i++] = s.fillFromImpl(impl);
}
}
dest_field.set(dest, translation);
} else if (Schema.class.isAssignableFrom(orig_field.getType().getComponentType())
&& Iced.class.isAssignableFrom(dest_field.getType().getComponentType())) {
//
// Assigning an array of schema fields to an array of impl fields, e.g. a
// DeepLearningParametersV2[] into a DeepLearningParameters[]
//
// We can't check against the actual impl class I, because we can't instantiate the
// schema base classes to get the impl class from an instance:
// dest_field.getType().getComponentType().isAssignableFrom(((Schema)f.getType().getComponentType().newInstance()).getImplClass())) {
Class dest_component_class = dest_field.getType().getComponentType();
Iced[] translation =
(Iced[])
Array.newInstance(
dest_component_class, Array.getLength(orig_field.get(origin)));
int i = 0;
for (Schema s : ((Schema[]) orig_field.get(origin))) {
translation[i++] = s.createImpl();
}
dest_field.set(dest, translation);
} else {
throw H2O.fail(
"Don't know how to cast an array of: "
+ orig_field.getType().getComponentType()
+ " to an array of: "
+ dest_field.getType().getComponentType());
}
// end of array handling
} else if (dest_field.getType() == Key.class
&& Keyed.class.isAssignableFrom(orig_field.getType())) {
//
// Assigning a Keyed (e.g., a Frame or Model) to a Key.
//
dest_field.set(dest, ((Keyed) orig_field.get(origin))._key);
} else if (orig_field.getType() == Key.class
&& Keyed.class.isAssignableFrom(dest_field.getType())) {
//
// Assigning a Key (for e.g., a Frame or Model) to a Keyed (e.g., a Frame or Model).
//
Value v = DKV.get((Key) orig_field.get(origin));
dest_field.set(dest, (null == v ? null : v.get()));
} else if (KeyV3.class.isAssignableFrom(dest_field.getType())
&& Keyed.class.isAssignableFrom(orig_field.getType())) {
//
// Assigning a Keyed (e.g., a Frame or Model) to a KeyV1.
//
dest_field.set(
dest,
KeyV3.make(
((Class<? extends KeyV3>) dest_field.getType()),
((Keyed) orig_field.get(origin))._key));
} else if (KeyV3.class.isAssignableFrom(orig_field.getType())
&& Keyed.class.isAssignableFrom(dest_field.getType())) {
//
// Assigning a KeyV1 (for e.g., a Frame or Model) to a Keyed (e.g., a Frame or Model).
//
KeyV3 k = (KeyV3) orig_field.get(origin);
Value v = DKV.get(Key.make(k.name));
dest_field.set(dest, (null == v ? null : v.get()));
} else if (KeyV3.class.isAssignableFrom(dest_field.getType())
&& Key.class.isAssignableFrom(orig_field.getType())) {
//
// Assigning a Key to a KeyV1.
//
dest_field.set(
dest,
KeyV3.make(
((Class<? extends KeyV3>) dest_field.getType()), (Key) orig_field.get(origin)));
} else if (KeyV3.class.isAssignableFrom(orig_field.getType())
&& Key.class.isAssignableFrom(dest_field.getType())) {
//
// Assigning a KeyV1 to a Key.
//
KeyV3 k = (KeyV3) orig_field.get(origin);
dest_field.set(dest, (null == k.name ? null : Key.make(k.name)));
} else if (dest_field.getType() == Pattern.class
&& String.class.isAssignableFrom(orig_field.getType())) {
//
// Assigning a String to a Pattern.
//
dest_field.set(dest, Pattern.compile((String) orig_field.get(origin)));
} else if (orig_field.getType() == Pattern.class
&& String.class.isAssignableFrom(dest_field.getType())) {
//
// We are assigning a Pattern to a String.
//
dest_field.set(dest, orig_field.get(origin).toString());
} else if (dest_field.getType() == FrameV3.ColSpecifierV3.class
&& String.class.isAssignableFrom(orig_field.getType())) {
//
// Assigning a String to a ColSpecifier. Note that we currently support only the
// colname, not a frame name too.
//
dest_field.set(dest, new FrameV3.ColSpecifierV3((String) orig_field.get(origin)));
} else if (orig_field.getType() == FrameV3.ColSpecifierV3.class
&& String.class.isAssignableFrom(dest_field.getType())) {
//
// We are assigning a ColSpecifierV2 to a String. The column_name gets copied.
//
dest_field.set(dest, ((FrameV3.ColSpecifierV3) orig_field.get(origin)).column_name);
} else if (Enum.class.isAssignableFrom(dest_field.getType())
&& String.class.isAssignableFrom(orig_field.getType())) {
//
// Assigning a String into an enum field.
//
Class<Enum> dest_class = (Class<Enum>) dest_field.getType();
dest_field.set(dest, Enum.valueOf(dest_class, (String) orig_field.get(origin)));
} else if (Enum.class.isAssignableFrom(orig_field.getType())
&& String.class.isAssignableFrom(dest_field.getType())) {
//
// Assigning an enum field into a String.
//
Object o = orig_field.get(origin);
dest_field.set(dest, (o == null ? null : o.toString()));
} else if (Schema.class.isAssignableFrom(dest_field.getType())
&& Schema.getImplClass((Class<? extends Schema>) dest_field.getType())
.isAssignableFrom(orig_field.getType())) {
//
// Assigning an impl field into a schema field, e.g. a DeepLearningParameters into a
// DeepLearningParametersV2.
//
dest_field.set(
dest,
Schema.schema(
/* ((Schema)dest).getSchemaVersion() TODO: remove HACK!! */ 3,
(Class<? extends Iced>) orig_field.get(origin).getClass())
.fillFromImpl((Iced) orig_field.get(origin)));
} else if (Schema.class.isAssignableFrom(orig_field.getType())
&& Schema.getImplClass((Class<? extends Schema>) orig_field.getType())
.isAssignableFrom(dest_field.getType())) {
//
// Assigning a schema field into an impl field, e.g. a DeepLearningParametersV2 into a
// DeepLearningParameters.
//
Schema s = ((Schema) orig_field.get(origin));
dest_field.set(dest, s.fillImpl(s.createImpl()));
} else if ((Schema.class.isAssignableFrom(dest_field.getType())
&& Key.class.isAssignableFrom(orig_field.getType()))) {
//
// Assigning an impl field fetched via a Key into a schema field, e.g. a
// DeepLearningParameters into a DeepLearningParametersV2.
// Note that unlike the cases above we don't know the type of the impl class until we
// fetch in the body of the if.
//
Key origin_key = (Key) orig_field.get(origin);
Value v = DKV.get(origin_key);
if (null == v || null == v.get()) {
dest_field.set(dest, null);
} else {
if (((Schema) dest_field.get(dest))
.getImplClass()
.isAssignableFrom(v.get().getClass())) {
Schema s = ((Schema) dest_field.get(dest));
dest_field.set(
dest,
Schema.schema(s.getSchemaVersion(), s.getImplClass()).fillFromImpl(v.get()));
} else {
Log.err(
"Can't fill Schema of type: "
+ dest_field.getType()
+ " with value of type: "
+ v.getClass()
+ " fetched from Key: "
+ origin_key);
dest_field.set(dest, null);
}
}
} else if (Schema.class.isAssignableFrom(orig_field.getType())
&& Keyed.class.isAssignableFrom(dest_field.getType())) {
//
// Assigning a schema field into a Key field, e.g. a DeepLearningV2 into a
// (DeepLearningParameters) key.
//
Schema s = ((Schema) orig_field.get(origin));
dest_field.set(dest, ((Keyed) s.fillImpl(s.createImpl()))._key);
} else {
//
// Normal case: not doing any type conversion.
//
dest_field.set(dest, orig_field.get(origin));
}
}
} catch (IllegalAccessException e) {
Log.err(
"Illegal access exception trying to copy field: "
+ origin_name
+ " of class: "
+ origin.getClass()
+ " to field: "
+ dest_name
+ " of class: "
+ dest.getClass());
} catch (InstantiationException e) {
Log.err(
"Instantiation exception trying to copy field: "
+ origin_name
+ " of class: "
+ origin.getClass()
+ " to field: "
+ dest_name
+ " of class: "
+ dest.getClass());
}
}
}
// -----------
// Atomically get a read-lock, preventing future deletes or updates
public static void read_lock(Key k, Key job_key) {
Value val = DKV.get(k);
if (val.isLockable()) ((Lockable) val.get()).read_lock(job_key); // Lockable being locked
}
// Read racy progress in a non-racy way: read the DKV exactly once,
// null-checking as we go. Handles the case where the Job is being removed
// exactly when we are reading progress e.g. for the GUI.
private Progress getProgress() {
Key k = _progressKey;
Value val;
return k != null && (val = DKV.get(k)) != null ? (Progress) val.get() : null;
}
public static <T extends Freezable> T get(Key k, T t) {
Value v = UKV.get(k);
if (v == null) return null;
return v.get(t);
}
